//intenal, may fail //may return nil func pubkeyFromSeckey(seckey []byte) []byte { if len(seckey) != 32 { log.Panic("seckey length invalid") } if secp.SeckeyIsValid(seckey) != 1 { log.Panic("always ensure seckey is valid") return nil } var pubkey []byte = secp.GeneratePublicKey(seckey) //always returns true if pubkey == nil { log.Panic("ERROR: impossible, secp.BaseMultiply always returns true") return nil } if len(pubkey) != 33 { log.Panic("ERROR: impossible, invalid pubkey length") } if ret := secp.PubkeyIsValid(pubkey); ret != 1 { log.Panic("ERROR: pubkey invald, ret=%s", ret) return nil } if ret := VerifyPubkey(pubkey); ret != 1 { log.Printf("seckey= %s", hex.EncodeToString(seckey)) log.Printf("pubkey= %s", hex.EncodeToString(pubkey)) log.Panic("ERROR: pubkey verification failed, for deterministic. ret=%d", ret) return nil } return pubkey }
// Generate a human readable sha1 hash of the given file path func hashFile(path string) (hashes FileInfo, err error) { f, err := os.Open(path) if err != nil { return } defer f.Close() reader := bufio.NewReader(f) if GetConfig().Hashes.SHA1 { sha1Hash := sha1.New() _, err = io.Copy(sha1Hash, reader) if err == nil { hashes.Sha1 = hex.EncodeToString(sha1Hash.Sum(nil)) } } if GetConfig().Hashes.SHA256 { sha256Hash := sha256.New() _, err = io.Copy(sha256Hash, reader) if err == nil { hashes.Sha256 = hex.EncodeToString(sha256Hash.Sum(nil)) } } if GetConfig().Hashes.MD5 { md5Hash := md5.New() _, err = io.Copy(md5Hash, reader) if err == nil { hashes.Md5 = hex.EncodeToString(md5Hash.Sum(nil)) } } return }
func (socket *mongoSocket) loginClassic(cred Credential) error { // Note that this only works properly because this function is // synchronous, which means the nonce won't get reset while we're // using it and any other login requests will block waiting for a // new nonce provided in the defer call below. nonce, err := socket.getNonce() if err != nil { return err } defer socket.resetNonce() psum := md5.New() psum.Write([]byte(cred.Username + ":mongo:" + cred.Password)) ksum := md5.New() ksum.Write([]byte(nonce + cred.Username)) ksum.Write([]byte(hex.EncodeToString(psum.Sum(nil)))) key := hex.EncodeToString(ksum.Sum(nil)) cmd := authCmd{Authenticate: 1, User: cred.Username, Nonce: nonce, Key: key} res := authResult{} return socket.loginRun(cred.Source, &cmd, &res, func() error { if !res.Ok { return errors.New(res.ErrMsg) } socket.Lock() socket.dropAuth(cred.Source) socket.creds = append(socket.creds, cred) socket.Unlock() return nil }) }
func (mod *module) introduceVia(router *e3x.Exchange, to hashname.H) error { localIdent, err := mod.e.LocalIdentity() if err != nil { return err } keys := localIdent.Keys() parts := hashname.PartsFromKeys(keys) for csid, key := range keys { inner := lob.New(key.Public()) for partCSID, part := range parts { if partCSID == csid { inner.Header().SetBool(hex.EncodeToString([]byte{partCSID}), true) } else { inner.Header().SetString(hex.EncodeToString([]byte{partCSID}), part) } } body, err := lob.Encode(inner) if err != nil { return err } err = mod.peerVia(router, to, body) if err != nil { return err } } return nil }
func (c *CoinsDB) Put(utxo bitcoin.Utxo) error { c.lock.Lock() defer c.lock.Unlock() tx, err := c.db.Begin() if err != nil { return err } stmt, err := tx.Prepare("insert into coins(outpoint, value, scriptPubKey) values(?,?,?)") if err != nil { return err } outpoint := hex.EncodeToString(utxo.Txid) + ":" + strconv.Itoa(utxo.Index) defer stmt.Close() _, err = stmt.Exec( outpoint, utxo.Value, hex.EncodeToString(utxo.ScriptPubKey), ) if err != nil { tx.Rollback() return err } tx.Commit() return nil }
// Response is called by the HTTP server to handle a new OCSP request. func (src *DBSource) Response(req *ocsp.Request) (response []byte, present bool) { log := blog.GetAuditLogger() // Check that this request is for the proper CA if bytes.Compare(req.IssuerKeyHash, src.caKeyHash) != 0 { log.Debug(fmt.Sprintf("Request intended for CA Cert ID: %s", hex.EncodeToString(req.IssuerKeyHash))) present = false return } serialString := core.SerialToString(req.SerialNumber) log.Debug(fmt.Sprintf("Searching for OCSP issued by us for serial %s", serialString)) var ocspResponse core.OCSPResponse // Note: we order by id rather than createdAt, because otherwise we sometimes // get the wrong result if a certificate is revoked in the same second as its // last update (e.g. client issues and instant revokes). err := src.dbMap.SelectOne(&ocspResponse, "SELECT * from ocspResponses WHERE serial = :serial ORDER BY id DESC LIMIT 1;", map[string]interface{}{"serial": serialString}) if err != nil { present = false return } log.Info(fmt.Sprintf("OCSP Response sent for CA=%s, Serial=%s", hex.EncodeToString(src.caKeyHash), serialString)) response = ocspResponse.Response present = true return }
func Test_Abnormal_Keys(t *testing.T) { for i := 0; i < 32*1024; i++ { seed := RandByte(32) pubkey1, seckey1 := generateDeterministicKeyPair(seed) if seckey1 == nil { t.Fail() } if pubkey1 == nil { t.Fail() } if VerifyPubkey(pubkey1) != 1 { seed_hex := hex.EncodeToString(seed) seckey_hex := hex.EncodeToString(seckey1) log.Printf("seed= %s", seed_hex) log.Printf("seckey= %s", seckey_hex) t.Errorf("GenerateKeyPair, generates key that fails validation, run=%i", i) } } }
// The timestamp in hex encoded form. func (me UUID) String() string { return hex.EncodeToString(me[0:4]) + "-" + hex.EncodeToString(me[4:6]) + "-" + hex.EncodeToString(me[6:8]) + "-" + hex.EncodeToString(me[8:10]) + "-" + hex.EncodeToString(me[10:16]) }
// Convert a hash into a string with hex encoding func (h *Hash) String() string { if h == nil { return hex.EncodeToString(nil) } else { return hex.EncodeToString(h[:]) } }
func (d *Deb) hashSections() (string, error) { h1 := sha1.New() h5 := md5.New() w := io.MultiWriter(h1, h5) _, err := d.f.Seek(0, 0) if err != nil { return "", &InvalidDeb{d, err} } s := "" rd := ar.NewReader(d.f) for { h1.Reset() h5.Reset() hdr, err := rd.Next() if err == io.EOF { return s, nil } else if err != nil { return "", &InvalidDeb{d, err} } _, err = io.Copy(w, rd) if err != nil { return "", &InvalidDeb{d, err} } h1x := hex.EncodeToString(h1.Sum(nil)) h5x := hex.EncodeToString(h5.Sum(nil)) s += fmt.Sprintf("\t%s %s %d %s\n", h5x, h1x, hdr.Size, hdr.Name) } }
func TestJWKSymmetricKey(t *testing.T) { sample1 := `{"kty":"oct","alg":"A128KW","k":"GawgguFyGrWKav7AX4VKUg"}` sample2 := `{"kty":"oct","k":"AyM1SysPpbyDfgZld3umj1qzKObwVMkoqQ-EstJQLr_T-1qS0gZH75aKtMN3Yj0iPS4hcgUuTwjAzZr1Z9CAow","kid":"HMAC key used in JWS spec Appendix A.1 example"}` var jwk1 JsonWebKey json.Unmarshal([]byte(sample1), &jwk1) if jwk1.Algorithm != "A128KW" { t.Errorf("expected Algorithm to be A128KW, but was '%s'", jwk1.Algorithm) } expected1 := fromHexBytes("19ac2082e1721ab58a6afec05f854a52") if !bytes.Equal(jwk1.Key.([]byte), expected1) { t.Errorf("expected Key to be '%s', but was '%s'", hex.EncodeToString(expected1), hex.EncodeToString(jwk1.Key.([]byte))) } var jwk2 JsonWebKey json.Unmarshal([]byte(sample2), &jwk2) if jwk2.KeyID != "HMAC key used in JWS spec Appendix A.1 example" { t.Errorf("expected KeyID to be 'HMAC key used in JWS spec Appendix A.1 example', but was '%s'", jwk2.KeyID) } expected2 := fromHexBytes(` 0323354b2b0fa5bc837e0665777ba68f5ab328e6f054c928a90f84b2d2502ebf d3fb5a92d20647ef968ab4c377623d223d2e2172052e4f08c0cd9af567d080a3`) if !bytes.Equal(jwk2.Key.([]byte), expected2) { t.Errorf("expected Key to be '%s', but was '%s'", hex.EncodeToString(expected2), hex.EncodeToString(jwk2.Key.([]byte))) } }
func (s *SignupJoinEngine) Post(arg SignupJoinEngineRunArg) (err error) { var res *libkb.APIRes var ppGenTmp int res, err = s.G().API.Post(libkb.APIArg{ Endpoint: "signup", Args: libkb.HTTPArgs{ "salt": libkb.S{Val: hex.EncodeToString(arg.PWSalt)}, "pwh": libkb.S{Val: hex.EncodeToString(arg.PWHash)}, "username": libkb.S{Val: arg.Username}, "email": libkb.S{Val: arg.Email}, "invitation_id": libkb.S{Val: arg.InviteCode}, "pwh_version": libkb.I{Val: int(triplesec.Version)}, "skip_mail": libkb.B{Val: arg.SkipMail}, }}) if err == nil { s.username = libkb.NewNormalizedUsername(arg.Username) libkb.GetUIDVoid(res.Body.AtKey("uid"), &s.uid, &err) res.Body.AtKey("session").GetStringVoid(&s.session, &err) res.Body.AtKey("csrf_token").GetStringVoid(&s.csrf, &err) res.Body.AtPath("me.basics.passphrase_generation").GetIntVoid(&ppGenTmp, &err) } if err == nil { err = libkb.CheckUIDAgainstUsername(s.uid, arg.Username) s.ppGen = libkb.PassphraseGeneration(ppGenTmp) } return }
// Tested functions: // EncodedBytesToBigInt // BigIntToFieldElement // FieldElementToEncodedBytes // BigIntToEncodedBytes // FieldElementToBigInt // EncodedBytesToFieldElement func TestConversion(t *testing.T) { for _, vector := range testConversionVectors() { // Test encoding to FE --> bytes. feFB := EncodedBytesToFieldElement(vector.bIn) feTB := FieldElementToEncodedBytes(feFB) assert.Equal(t, vector.bIn, feTB) // Test encoding to big int --> FE --> bytes. big := EncodedBytesToBigInt(vector.bIn) fe := BigIntToFieldElement(big) b := FieldElementToEncodedBytes(fe) assert.Equal(t, vector.bIn, b) // Test encoding to big int --> bytes. b = BigIntToEncodedBytes(big) assert.Equal(t, vector.bIn, b) // Test encoding FE --> big int --> bytes. feBig := FieldElementToBigInt(fe) b = BigIntToEncodedBytes(feBig) assert.Equal(t, vector.bIn, b) // Test python lib bytes --> int vs our results. args := []string{"testdata/decodeint.py", hex.EncodeToString(vector.bIn[:])} pyNumStr, _ := exec.Command("python", args...).Output() stripped := strings.TrimSpace(string(pyNumStr)) assert.Equal(t, stripped, big.String()) // Test python lib int --> bytes versus our results. args = []string{"testdata/encodeint.py", big.String()} pyHexStr, _ := exec.Command("python", args...).Output() stripped = strings.TrimSpace(string(pyHexStr)) assert.Equal(t, hex.EncodeToString(vector.bIn[:]), string(stripped)) } }
// Tested functions: // BigIntPointToEncodedBytes // extendedToBigAffine // EncodedBytesToBigIntPoint func TestPointConversion(t *testing.T) { curve := new(TwistedEdwardsCurve) curve.InitParam25519() for _, vector := range testPointConversionVectors() { x, y, err := curve.EncodedBytesToBigIntPoint(vector.bIn) // The random point wasn't on the curve. if err != nil { continue } yB := BigIntPointToEncodedBytes(x, y) assert.Equal(t, vector.bIn, yB) // Test python lib bytes --> point vs our results. args := []string{"testdata/decodepoint.py", hex.EncodeToString(vector.bIn[:])} pyNumStr, _ := exec.Command("python", args...).Output() stripped := strings.TrimSpace(string(pyNumStr)) var buffer bytes.Buffer buffer.WriteString(x.String()) buffer.WriteString(",") buffer.WriteString(y.String()) localStr := buffer.String() assert.Equal(t, localStr, stripped) // Test python lib point --> bytes versus our results. args = []string{"testdata/encodepoint.py", x.String(), y.String()} pyHexStr, _ := exec.Command("python", args...).Output() stripped = strings.TrimSpace(string(pyHexStr)) assert.Equal(t, hex.EncodeToString(vector.bIn[:]), string(stripped)) } }
func (o arc4Verifier) validate(count string, offset uint64, key, plaintext, expectedCiphertext []byte) { if offset%16 != 0 || len(plaintext) != 16 || len(expectedCiphertext) != 16 { panic(fmt.Errorf("Unexpected input value encountered: offset=%v; len(plaintext)=%v; len(expectedCiphertext)=%v", offset, len(plaintext), len(expectedCiphertext))) } stream, err := rc4.NewCipher(key) if err != nil { panic(err) } var currentOffset uint64 = 0 ciphertext := make([]byte, len(plaintext)) for currentOffset <= offset { stream.XORKeyStream(ciphertext, plaintext) currentOffset += uint64(len(plaintext)) } if !bytes.Equal(ciphertext, expectedCiphertext) { panic(fmt.Errorf("vector mismatch @ COUNT = %s:\n %s != %s\n", count, hex.EncodeToString(expectedCiphertext), hex.EncodeToString(ciphertext))) } }
// Print outputs a formatted dump of the RTP packet. func (rp *DataPacket) Print(label string) { fmt.Printf("RTP Packet at: %s\n", label) fmt.Printf(" fixed header dump: %s\n", hex.EncodeToString(rp.buffer[0:rtpHeaderLength])) fmt.Printf(" Version: %d\n", (rp.buffer[0]&0xc0)>>6) fmt.Printf(" Padding: %t\n", rp.Padding()) fmt.Printf(" Extension: %t\n", rp.ExtensionBit()) fmt.Printf(" Contributing SRCs: %d\n", rp.CsrcCount()) fmt.Printf(" Marker: %t\n", rp.Marker()) fmt.Printf(" Payload type: %d (0x%x)\n", rp.PayloadType(), rp.PayloadType()) fmt.Printf(" Sequence number: %d (0x%x)\n", rp.Sequence(), rp.Sequence()) fmt.Printf(" Timestamp: %d (0x%x)\n", rp.Timestamp(), rp.Timestamp()) fmt.Printf(" SSRC: %d (0x%x)\n", rp.Ssrc(), rp.Ssrc()) if rp.CsrcCount() > 0 { cscr := rp.CsrcList() fmt.Printf(" CSRC list:\n") for i, v := range cscr { fmt.Printf(" %d: %d (0x%x)\n", i, v, v) } } if rp.ExtensionBit() { extLen := rp.ExtensionLength() fmt.Printf(" Extentsion length: %d\n", extLen) offsetExt := rtpHeaderLength + int(rp.CsrcCount()*4) fmt.Printf(" extension: %s\n", hex.EncodeToString(rp.buffer[offsetExt:offsetExt+extLen])) } payOffset := rtpHeaderLength + int(rp.CsrcCount()*4) + rp.ExtensionLength() fmt.Printf(" payload: %s\n", hex.EncodeToString(rp.buffer[payOffset:rp.inUse])) }
func (s *ParseMessageTestSuite) TestParseTextAttachment() { loop := 1 for i := 0; i < loop; i++ { fileHandler, err := os.Open("fixtures/text_attachment.eml") assert.Nil(s.T(), err) reader := bufio.NewReader(fileHandler) parse := NewParse(reader) assert.Equal(s.T(), parse.To(), "Team R&D <*****@*****.**>") hasher := md5.New() text, _ := parse.Text() hasher.Write([]byte(text)) hashString := hex.EncodeToString(hasher.Sum(nil)) assert.Equal(s.T(), hashString, "b5b94cd495174ab6e4443fa81847b6ce") hasher.Reset() html, _ := parse.Html() hasher.Write([]byte(html)) hashString = hex.EncodeToString(hasher.Sum(nil)) assert.Equal(s.T(), hashString, "d41d8cd98f00b204e9800998ecf8427e") hasher.Reset() attachments := parse.Attachment() for key, value := range attachments { assert.Equal(s.T(), key, "content-type-sorted-distilled.txt") hasher.Write(value) hashString = hex.EncodeToString(hasher.Sum(nil)) assert.Equal(s.T(), hashString, "bcd2881b9b06f24960d4998567be37bd") hasher.Reset() } fileHandler.Close() } }
// Response is called by the HTTP server to handle a new OCSP request. func (src *DBSource) Response(req *ocsp.Request) ([]byte, bool) { // Check that this request is for the proper CA if bytes.Compare(req.IssuerKeyHash, src.caKeyHash) != 0 { src.log.Debug(fmt.Sprintf("Request intended for CA Cert ID: %s", hex.EncodeToString(req.IssuerKeyHash))) return nil, false } serialString := core.SerialToString(req.SerialNumber) src.log.Debug(fmt.Sprintf("Searching for OCSP issued by us for serial %s", serialString)) var response []byte defer func() { if len(response) != 0 { src.log.Info(fmt.Sprintf("OCSP Response sent for CA=%s, Serial=%s", hex.EncodeToString(src.caKeyHash), serialString)) } }() err := src.dbMap.SelectOne( &response, "SELECT ocspResponse FROM certificateStatus WHERE serial = :serial", map[string]interface{}{"serial": serialString}, ) if err != nil && err != sql.ErrNoRows { src.log.Err(fmt.Sprintf("Failed to retrieve response from certificateStatus table: %s", err)) } if err != nil { return nil, false } return response, true }
func main() { fmt.Printf("Login......\n") unixTime := getUnixTime() //*******************token process begin************************ var orignalToken = getToken(unixTime) //fmt.Printf("%s \n",orignalToken) vm.Set("token", orignalToken) token, error := vm.Run(encyptFunctions) if error != nil { //handler error } md5_t := md5.New() s_token, error := token.ToString() if error != nil { //handler error } md5_t.Write([]byte(s_token)) true_token := hex.EncodeToString(md5_t.Sum(nil)) //*******************token process end************************ time.Sleep(1 * time.Second) email := "" //your email pwd := "" //your password md5_p := md5.New() md5_p.Write([]byte(pwd)) passwd := hex.EncodeToString(md5_p.Sum(nil)) result := login(true_token, unixTime, email, passwd) fmt.Printf("%s\n", result) }
// add P2SH pre-signing data into a raw tx func make_p2sh() { tx := raw_tx_from_file(*rawtx) if tx == nil { fmt.Println("ERROR: Cannot decode the raw transaction") return } d, er := hex.DecodeString(*p2sh) if er != nil { println("P2SH hex data:", er.Error()) return } ms, er := btc.NewMultiSigFromP2SH(d) if er != nil { println("Decode P2SH:", er.Error()) return } fmt.Println("The P2SH data points to address", ms.BtcAddr(testnet).String()) sd := ms.Bytes() for i := range tx.TxIn { tx.TxIn[i].ScriptSig = sd fmt.Println("Input number", i, " - hash to sign:", hex.EncodeToString(tx.SignatureHash(d, i, btc.SIGHASH_ALL))) } ioutil.WriteFile(MultiToSignOut, []byte(hex.EncodeToString(tx.Serialize())), 0666) fmt.Println("Transaction with", len(tx.TxIn), "inputs ready for multi-signing, stored in", MultiToSignOut) }
func TestAddPoliciesWithQualifiers(t *testing.T) { var cert x509.Certificate addPolicies(&cert, []config.CertificatePolicy{ config.CertificatePolicy{ ID: config.OID{1, 2, 3, 4}, Qualifiers: []config.CertificatePolicyQualifier{ config.CertificatePolicyQualifier{ Type: "id-qt-cps", Value: "http://example.com/cps", }, config.CertificatePolicyQualifier{ Type: "id-qt-unotice", Value: "Do What Thou Wilt", }, }, }, }) if len(cert.ExtraExtensions) != 1 { t.Fatal("No extension added") } ext := cert.ExtraExtensions[0] if !reflect.DeepEqual(ext.Id, asn1.ObjectIdentifier{2, 5, 29, 32}) { t.Fatal(fmt.Sprintf("Wrong OID for policy qualifier %v", ext.Id)) } if ext.Critical { t.Fatal("Policy qualifier marked critical") } expectedBytes, _ := hex.DecodeString("304e304c06032a03043045302206082b060105050702011616687474703a2f2f6578616d706c652e636f6d2f637073301f06082b0601050507020230130c11446f20576861742054686f752057696c74") if !bytes.Equal(ext.Value, expectedBytes) { t.Fatal(fmt.Sprintf("Value didn't match expected bytes: %s vs %s", hex.EncodeToString(ext.Value), hex.EncodeToString(expectedBytes))) } }
// Print all the piblic addresses func dump_addrs() { f, _ := os.Create("wallet.txt") fmt.Fprintln(f, "# Deterministic Walet Type", *waltype) if type2_secret != nil { fmt.Fprintln(f, "#", hex.EncodeToString(publ_addrs[0].Pubkey)) fmt.Fprintln(f, "#", hex.EncodeToString(type2_secret.Bytes())) } for i := range publ_addrs { if !*noverify { if er := btc.VerifyKeyPair(priv_keys[i], publ_addrs[i].Pubkey); er != nil { println("Something wrong with key at index", i, " - abort!", er.Error()) os.Exit(1) } } fmt.Println(publ_addrs[i].String(), labels[i]) if f != nil { fmt.Fprintln(f, publ_addrs[i].String(), labels[i]) } } if f != nil { f.Close() fmt.Println("You can find all the addresses in wallet.txt file") } }
func (kvb *kvBatch) IndexRom(rom *types.Rom) error { glog.V(4).Infof("indexing rom %s", rom.Name) if rom.Sha1 != nil { if rom.Crc != nil { glog.V(4).Infof("declaring crc %s -> sha1 %s mapping", hex.EncodeToString(rom.Crc), hex.EncodeToString(rom.Sha1)) err := kvb.crcsha1Batch.Set(rom.CrcWithSizeAndSha1Key(nil), oneValue) if err != nil { return err } kvb.size += int64(sha1.Size) } if rom.Md5 != nil { glog.V(4).Infof("declaring md5 %s -> sha1 %s mapping", hex.EncodeToString(rom.Md5), hex.EncodeToString(rom.Sha1)) err := kvb.md5sha1Batch.Set(rom.Md5WithSizeAndSha1Key(nil), oneValue) if err != nil { return err } kvb.size += int64(sha1.Size) } } else { glog.V(4).Infof("indexing rom %s with missing SHA1", rom.Name) } return nil }
// Create a new encryption key and encrypt it using the user-provided // passphrase. Prints output to stdout that gives text to add to the // ~/.skicka.config file to store the encryption key. func generateKey() { passphrase := os.Getenv(passphraseEnvironmentVariable) if passphrase == "" { printErrorAndExit(fmt.Errorf(passphraseEnvironmentVariable + " environment variable not set.")) } // Derive a 64-byte hash from the passphrase using PBKDF2 with 65536 // rounds of SHA256. salt := getRandomBytes(32) hash := pbkdf2.Key([]byte(passphrase), salt, 65536, 64, sha256.New) if len(hash) != 64 { printErrorAndExit(fmt.Errorf("incorrect key size returned by pbkdf2 %d", len(hash))) } // We'll store the first 32 bytes of the hash to use to confirm the // correct passphrase is given on subsequent runs. passHash := hash[:32] // And we'll use the remaining 32 bytes as a key to encrypt the actual // encryption key. (These bytes are *not* stored). keyEncryptKey := hash[32:] // Generate a random encryption key and encrypt it using the key // derived from the passphrase. key := getRandomBytes(32) iv := getRandomBytes(16) encryptedKey := encryptBytes(keyEncryptKey, iv, key) fmt.Printf("; Add the following lines to the [encryption] section\n") fmt.Printf("; of your ~/.skicka.config file.\n") fmt.Printf("\tsalt=%s\n", hex.EncodeToString(salt)) fmt.Printf("\tpassphrase-hash=%s\n", hex.EncodeToString(passHash)) fmt.Printf("\tencrypted-key=%s\n", hex.EncodeToString(encryptedKey)) fmt.Printf("\tencrypted-key-iv=%s\n", hex.EncodeToString(iv)) }
// Response is called by the HTTP server to handle a new OCSP request. func (src *DBSource) Response(req *ocsp.Request) (response []byte, present bool) { log := blog.GetAuditLogger() // Check that this request is for the proper CA if bytes.Compare(req.IssuerKeyHash, src.caKeyHash) != 0 { log.Debug(fmt.Sprintf("Request intended for CA Cert ID: %s", hex.EncodeToString(req.IssuerKeyHash))) present = false return } serialString := core.SerialToString(req.SerialNumber) log.Debug(fmt.Sprintf("Searching for OCSP issued by us for serial %s", serialString)) var ocspResponse core.OCSPResponse err := src.dbMap.SelectOne(&ocspResponse, "SELECT * from ocspResponses WHERE serial = :serial ORDER BY createdAt DESC LIMIT 1;", map[string]interface{}{"serial": serialString}) if err != nil { present = false return } log.Info(fmt.Sprintf("OCSP Response sent for CA=%s, Serial=%s", hex.EncodeToString(src.caKeyHash), serialString)) response = ocspResponse.Response present = true return }
func readRaptor() Ride { encodedBits, err := ioutil.ReadFile("rides/raptor.td4") if err != nil { panic(err) } z := rle.NewReader(bytes.NewReader(encodedBits)) if err != nil { panic(err) } var bitbuffer bytes.Buffer bitbuffer.ReadFrom(z) decrypted := bitbuffer.Bytes() for i := 0; i < 40; i++ { // encode the value of i as hex ds := hex.EncodeToString([]byte{byte(i)}) bitValueInHex := hex.EncodeToString([]byte{decrypted[i]}) fmt.Printf("%s: %s\n", ds, bitValueInHex) } // r is a pointer r := new(Ride) Unmarshal(decrypted, r) bits, err := Marshal(r) fmt.Println(bits) return *r }
// test create object func (s *MyCacheSuite) TestNewObjectCanBeWritten(c *C) { err := dc.MakeBucket("foo", "private", nil, nil) c.Assert(err, IsNil) data := "Hello World" hasher := md5.New() hasher.Write([]byte(data)) expectedMd5Sum := base64.StdEncoding.EncodeToString(hasher.Sum(nil)) reader := ioutil.NopCloser(bytes.NewReader([]byte(data))) actualMetadata, err := dc.CreateObject("foo", "obj", expectedMd5Sum, int64(len(data)), reader, map[string]string{"contentType": "application/octet-stream"}, nil) c.Assert(err, IsNil) c.Assert(actualMetadata.MD5Sum, Equals, hex.EncodeToString(hasher.Sum(nil))) var buffer bytes.Buffer size, err := dc.GetObject(&buffer, "foo", "obj", 0, 0) c.Assert(err, IsNil) c.Assert(size, Equals, int64(len(data))) c.Assert(buffer.Bytes(), DeepEquals, []byte(data)) actualMetadata, err = dc.GetObjectMetadata("foo", "obj", nil) c.Assert(err, IsNil) c.Assert(hex.EncodeToString(hasher.Sum(nil)), Equals, actualMetadata.MD5Sum) c.Assert(int64(len(data)), Equals, actualMetadata.Size) }
func handleEntry(ctx *web.Context, hash string) { type entry struct { ChainID string Content string ExtIDs []string } e := new(entry) if entry, err := factomapi.EntryByHash(hash); err != nil { wsLog.Error(err) ctx.WriteHeader(httpBad) ctx.Write([]byte(err.Error())) return } else { e.ChainID = entry.ChainID.String() e.Content = hex.EncodeToString(entry.Content) for _, v := range entry.ExtIDs { e.ExtIDs = append(e.ExtIDs, hex.EncodeToString(v)) } } if p, err := json.Marshal(e); err != nil { wsLog.Error(err) ctx.WriteHeader(httpBad) ctx.Write([]byte(err.Error())) return } else { ctx.Write(p) } }
func GetMember(email, password string) (Member, error) { log.Printf("Get member '%s' ('%s')", email, password) db, err := GetDBConnection() if err == nil { defer db.Close() pwd := sha256.Sum256([]byte(password)) log.Printf("Encrypted password: %s", hex.EncodeToString(pwd[:])) row := db.QueryRow(`SELECT id, email, first_name FROM Member WHERE email = $1 AND password = $2`, email, hex.EncodeToString(pwd[:]), ) result := Member{} err = row.Scan(&result.id, &result.email, &result.firstName) log.Printf("Err: %v", err) if err == nil { return result, nil } else { return result, errors.New("Unable to find Member with email: " + email) } } else { return Member{}, errors.New("Unable to get database connection") } }
// reads the configuration file from the path specified by // the config command line flag. func readConfig(configFile string) error { b, err := ioutil.ReadFile(configFile) if err != nil { return err } err = json.Unmarshal(b, &config) if err != nil { return err } cookieAuthKey, err = hex.DecodeString(*config.CookieAuthKeyHexStr) if err != nil { return err } cookieEncrKey, err = hex.DecodeString(*config.CookieEncrKeyHexStr) if err != nil { return err } secureCookie = securecookie.New(cookieAuthKey, cookieEncrKey) // verify auth/encr keys are correct val := map[string]string{ "foo": "bar", } _, err = secureCookie.Encode(cookieName, val) if err != nil { // for convenience, if the auth/encr keys are not set, // generate valid, random value for them auth := securecookie.GenerateRandomKey(32) encr := securecookie.GenerateRandomKey(32) fmt.Printf("auth: %s\nencr: %s\n", hex.EncodeToString(auth), hex.EncodeToString(encr)) } // TODO: somehow verify twitter creds return err }