// 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
}
func TestAmqp_GetEmptyMethod(t *testing.T) {
if testing.Verbose() {
logp.LogInit(logp.LOG_DEBUG, "", false, true, []string{"amqp", "amqpdetailed"})
}
amqp := amqpModForTests()
amqp.sendRequest = true
data, err := hex.DecodeString("01000100000013003c004600000b526f626269" +
"654b65616e6501ce")
assert.Nil(t, err)
data2, err := hex.DecodeString("01000100000005003c004800ce")
assert.Nil(t, err)
tcptuple := testTCPTuple()
req := protos.Packet{Payload: data}
private := protos.ProtocolData(new(amqpPrivateData))
private = amqp.Parse(&req, tcptuple, 0, private)
req = protos.Packet{Payload: data2}
amqp.Parse(&req, tcptuple, 1, private)
trans := expectTransaction(t, amqp)
assert.Equal(t, "basic.get-empty", trans["method"])
assert.Equal(t, "basic.get RobbieKeane", trans["request"])
assert.Equal(t, "amqp", trans["type"])
assert.Equal(t, common.OK_STATUS, trans["status"])
}
func TestAmqp_RecoverMethod(t *testing.T) {
if testing.Verbose() {
logp.LogInit(logp.LOG_DEBUG, "", false, true, []string{"amqp", "amqpdetailed"})
}
amqp := amqpModForTests()
amqp.sendRequest = true
data, err := hex.DecodeString("01000100000005003c006e01ce")
assert.Nil(t, err)
data2, err := hex.DecodeString("01000100000004003c006fce")
assert.Nil(t, err)
tcptuple := testTCPTuple()
req := protos.Packet{Payload: data}
private := protos.ProtocolData(new(amqpPrivateData))
private = amqp.Parse(&req, tcptuple, 0, private)
req = protos.Packet{Payload: data2}
amqp.Parse(&req, tcptuple, 1, private)
trans := expectTransaction(t, amqp)
assert.Equal(t, "basic.recover", trans["method"])
assert.Equal(t, "basic.recover", trans["request"])
assert.Equal(t, "amqp", trans["type"])
assert.Equal(t, common.OK_STATUS, trans["status"])
assert.Equal(t, common.MapStr{"requeue": true}, trans["amqp"])
}
func Bond(nodeAddr, pubkey, unbondAddr, amtS, nonceS string) (*types.BondTx, error) {
pub, addrBytes, amt, nonce, err := checkCommon(nodeAddr, pubkey, "", amtS, nonceS)
if err != nil {
return nil, err
}
var pubKey account.PubKeyEd25519
var unbondAddrBytes []byte
if unbondAddr == "" {
pkb, _ := hex.DecodeString(pubkey)
copy(pubKey[:], pkb)
unbondAddrBytes = pubKey.Address()
} else {
unbondAddrBytes, err = hex.DecodeString(unbondAddr)
if err != nil {
return nil, fmt.Errorf("unbondAddr is bad hex: %v", err)
}
}
tx, err := types.NewBondTx(pub)
if err != nil {
return nil, err
}
_ = addrBytes
tx.AddInputWithNonce(pub, amt, int(nonce))
tx.AddOutput(unbondAddrBytes, amt)
return tx, nil
}
func TestAmqp_ConnectionCloseNoError(t *testing.T) {
if testing.Verbose() {
logp.LogInit(logp.LOG_DEBUG, "", false, true, []string{"amqp", "amqpdetailed"})
}
amqp := amqpModForTests()
amqp.hideConnectionInformation = false
data, err := hex.DecodeString("01000000000012000a003200c8076b74687862616900000000ce")
assert.Nil(t, err)
data2, err := hex.DecodeString("01000000000004000a0033ce")
assert.Nil(t, err)
tcptuple := testTCPTuple()
req := protos.Packet{Payload: data}
private := protos.ProtocolData(new(amqpPrivateData))
private = amqp.Parse(&req, tcptuple, 0, private)
req = protos.Packet{Payload: data2}
amqp.Parse(&req, tcptuple, 1, private)
trans := expectTransaction(t, amqp)
assert.Equal(t, "connection.close", trans["method"])
assert.Equal(t, "amqp", trans["type"])
assert.Equal(t, common.OK_STATUS, trans["status"])
assert.Nil(t, trans["notes"])
fields, ok := trans["amqp"].(common.MapStr)
assert.True(t, ok)
code, ok := fields["reply-code"].(uint16)
assert.True(t, ok)
assert.Equal(t, uint16(200), code)
}
func addCerts(csvFilename string, dbMap *gorp.DbMap, stats metrics.Statter, statsRate float32) {
file, err := os.Open(csvFilename)
cmd.FailOnError(err, "Could not open the file for reading")
csvReader := csv.NewReader(file)
for {
record, err := csvReader.Read()
if err == io.EOF {
break
} else if err != nil {
fmt.Println("Error:", err)
return
}
notAfter, err := time.Parse(datestampFormat, record[3])
spkiBytes, err := hex.DecodeString(record[4])
certDER, err := hex.DecodeString(record[7])
externalCert := core.ExternalCert{
SHA1: record[0],
Issuer: record[1],
Subject: record[2],
NotAfter: notAfter,
SPKI: spkiBytes,
Valid: record[5] == "1",
EV: record[6] == "1",
CertDER: certDER,
}
importStart := time.Now()
err = dbMap.Insert(&externalCert)
stats.TimingDuration("ExistingCert.Certs.ImportLatency", time.Since(importStart), statsRate)
stats.Inc("ExistingCert.Certs.Imported", 1, statsRate)
}
}
func TestAesKeyWrapInvalid(t *testing.T) {
kek, _ := hex.DecodeString("000102030405060708090A0B0C0D0E0F")
// Invalid unwrap input (bit flipped)
input0, _ := hex.DecodeString("1EA68C1A8112B447AEF34BD8FB5A7B828D3E862371D2CFE5")
block, _ := aes.NewCipher(kek)
_, err := KeyUnwrap(block, input0)
if err == nil {
t.Error("key unwrap failed to detect invalid input")
}
// Invalid unwrap input (truncated)
input1, _ := hex.DecodeString("1EA68C1A8112B447AEF34BD8FB5A7B828D3E862371D2CF")
_, err = KeyUnwrap(block, input1)
if err == nil {
t.Error("key unwrap failed to detect truncated input")
}
// Invalid wrap input (not multiple of 8)
input2, _ := hex.DecodeString("0123456789ABCD")
_, err = KeyWrap(block, input2)
if err == nil {
t.Error("key wrap accepted invalid input")
}
}
func TestGeneralSecp256k1(t *testing.T) {
// Sample expanded pubkey (Satoshi from Genesis block)
samplePubkey, _ := hex.DecodeString("04" +
"678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb6" +
"49f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f")
_, err := Secp256k1.ParsePubKey(samplePubkey)
if err != nil {
t.Errorf("failure parsing pubkey: %v", err)
}
// Sample compressed pubkey
samplePubkey, _ = hex.DecodeString("02" +
"4627032575180c2773b3eedd3a163dc2f3c6c84f9d0a1fc561a9578a15e6d0e3")
_, err = Secp256k1.ParsePubKey(samplePubkey)
if err != nil {
t.Errorf("failure parsing pubkey: %v", err)
}
// Sample signature from https://en.bitcoin.it/wiki/Transaction
sampleSig, _ := hex.DecodeString("30" +
"45" +
"02" +
"20" +
"6e21798a42fae0e854281abd38bacd1aeed3ee3738d9e1446618c4571d1090db" +
"02" +
"21" +
"00e2ac980643b0b82c0e88ffdfec6b64e3e6ba35e7ba5fdd7d5d6cc8d25c6b2415")
_, err = Secp256k1.ParseDERSignature(sampleSig)
if err != nil {
t.Errorf("failure parsing DER signature: %v", err)
}
}
func TestVerify(t *testing.T) {
pkey, _ := hex.DecodeString("040eaebcd1df2df853d66ce0e1b0fda07f67d1cabefde98514aad795b86a6ea66dbeb26b67d7a00e2447baeccc8a4cef7cd3cad67376ac1c5785aeebb4f6441c16")
hasz, _ := hex.DecodeString("3382219555ddbb5b00e0090f469e590ba1eae03c7f28ab937de330aa60294ed6")
sign, _ := hex.DecodeString("3045022100fe00e013c244062847045ae7eb73b03fca583e9aa5dbd030a8fd1c6dfcf11b1002207d0d04fed8fa1e93007468d5a9e134b0a7023b6d31db4e50942d43a250f4d07c01")
res := EC_Verify(pkey, sign, hasz)
if res != 1 {
t.Error("Verify failed")
}
hasz[0]++
res = EC_Verify(pkey, sign, hasz)
if res != 0 {
t.Error("Verify not failed while it should")
}
res = EC_Verify(pkey[:1], sign, hasz)
if res >= 0 {
t.Error("Negative result expected", res)
}
res = EC_Verify(pkey, sign[:1], hasz)
if res >= 0 {
t.Error("Yet negative result expected", res)
}
res = EC_Verify(pkey, sign, hasz[:1])
if res != 0 {
t.Error("Zero expected", res)
}
}
func (repo *postgresRepository) listenDaemon() error {
doneCh := registry.DoneChannel()
pqNotificationCh := repo.listener.NotificationChannel()
for {
select {
case <-doneCh:
return nil
case pqNotification, ok := <-pqNotificationCh:
if !ok {
return nil
}
decodedChannel, err := hex.DecodeString(pqNotification.Channel[1:]) // trim leading '_'
if err != nil {
return err
}
decodedPayload, err := hex.DecodeString(pqNotification.Extra)
if err != nil {
return err
}
repo.m.RLock()
for ch := range repo.listenChannels[string(decodedChannel)] {
ch <- string(decodedPayload)
}
repo.m.RUnlock()
}
}
}
func parseReadHeaders(s string) (info ReadInfo, err error) {
headers := strings.Split(s, ",")
if len(headers) < 3 {
err = fmt.Errorf("error: Split headers failed: %s", s)
return
}
node, derr := hex.DecodeString(headers[0])
if derr != nil {
err = fmt.Errorf("error: Decode Node failed (%s): %s", headers[0], derr)
return
}
info.FromNode = Node(node[0])
id, derr := strToUint16(headers[1])
if err != nil {
err = fmt.Errorf("error: Decode FromId failed (%s): %s", headers[1], derr)
return
}
info.FromId = Id(id)
rssi, derr := hex.DecodeString(headers[2])
if err != nil {
err = fmt.Errorf("error: Decode Rssi failed (%s): %s", headers[2], derr)
return
}
info.FromRssi = Rssi(rssi[0])
return
}
func TestVerify1(t *testing.T) {
for i := range ta {
pkey, _ := hex.DecodeString(ta[i][0])
sign, _ := hex.DecodeString(ta[i][1])
hasz, _ := hex.DecodeString(ta[i][2])
res := ecdsa_verify(pkey, sign, hasz)
if res != 1 {
t.Fatal("Verify failed at", i)
}
hasz[0]++
res = ecdsa_verify(pkey, sign, hasz)
if res != 0 {
t.Error("Verify not failed while it should", i)
}
res = ecdsa_verify(pkey[:1], sign, hasz)
if res >= 0 {
t.Error("Negative result expected", res, i)
}
res = ecdsa_verify(pkey, sign[:1], hasz)
if res >= 0 {
t.Error("Yet negative result expected", res, i)
}
res = ecdsa_verify(pkey, sign, hasz[:1])
if res != 0 {
t.Error("Zero expected", res, i)
}
}
}
// ParseShardingSpec parses a string that describes a sharding
// specification. a-b-c-d will be parsed as a-b, b-c, c-d. The empty
// string may serve both as the start and end of the keyspace: -a-b-
// will be parsed as start-a, a-b, b-end.
func ParseShardingSpec(spec string) ([]*topodatapb.KeyRange, error) {
parts := strings.Split(spec, "-")
if len(parts) == 1 {
return nil, fmt.Errorf("malformed spec: doesn't define a range: %q", spec)
}
old := parts[0]
ranges := make([]*topodatapb.KeyRange, len(parts)-1)
for i, p := range parts[1:] {
if p == "" && i != (len(parts)-2) {
return nil, fmt.Errorf("malformed spec: MinKey/MaxKey cannot be in the middle of the spec: %q", spec)
}
if p != "" && p <= old {
return nil, fmt.Errorf("malformed spec: shard limits should be in order: %q", spec)
}
s, err := hex.DecodeString(old)
if err != nil {
return nil, err
}
if len(s) == 0 {
s = nil
}
e, err := hex.DecodeString(p)
if err != nil {
return nil, err
}
if len(e) == 0 {
e = nil
}
ranges[i] = &topodatapb.KeyRange{Start: s, End: e}
old = p
}
return ranges, nil
}
func TestParse_LibbitconTX(t *testing.T) {
txData, err := hex.DecodeString(consensusScriptVerifyTx)
if err != nil {
t.Fatalf("Error decoding HEX tx from libbitcoin: %s", err)
return
}
prevTxScript, err := hex.DecodeString(consensusScriptVerifyPreviousOutputScript)
if err != nil {
t.Fatalf("Error decoding HEX tx from libbitcoin: %s", err)
return
}
t.Logf("TX data from libbitcoin: %v", txData)
tx := ParseUTXOBytes(txData)
// Call Verify_script
txInputIndex := uint(0)
result := consensus.Verify_script(&txData[0], int64(len(txData)), &prevTxScript[0], int64(len(prevTxScript)), txInputIndex, uint(consensus.Verify_flags_p2sh))
if result != consensus.Verify_result_eval_true {
t.Fatalf("Unexpected result from verify_script, expected %d, got %d", consensus.Verify_result_eval_true, result)
}
t.Log(result)
t.Log(consensus.Verify_result_eval_true)
t.Logf("TX from %v", tx)
}
func handleConnection(n net.Conn) {
l := make([]byte, 1024)
_, err := n.Read(l)
if err != nil {
panic("server read error")
}
// Bind Resp
d, _ := hex.DecodeString("000000158000000900000000000000016875676f00")
n.Write(d)
time.Sleep(100 * time.Millisecond)
// Invalid CMD ID
d, _ = hex.DecodeString("0000001090000015000000005222b523")
n.Write(d)
time.Sleep(100 * time.Millisecond)
// PDU Len different than read bytes
d, _ = hex.DecodeString("000000178000000900000000000000016875676f00")
n.Write(d)
time.Sleep(100 * time.Millisecond)
// Max PDU Len err
d, _ = hex.DecodeString("0000F01080000015000000005222b526")
n.Write(d)
}
func (k *Key) UnmarshalJSON(j []byte) (err error) {
keyJSON := new(plainKeyJSON)
err = json.Unmarshal(j, &keyJSON)
if err != nil {
return err
}
u := new(uuid.UUID)
*u = uuid.Parse(keyJSON.Id)
k.Id = *u
addr, err := hex.DecodeString(keyJSON.Address)
if err != nil {
return err
}
privkey, err := hex.DecodeString(keyJSON.PrivateKey)
if err != nil {
return err
}
k.Address = common.BytesToAddress(addr)
k.PrivateKey = ToECDSA(privkey)
return nil
}
// Tests the code for a subcurrency contract compiled by serpent
func TestSubcurrency(t *testing.T) {
st := newAppState()
// Create accounts
account1 := &Account{
Address: LeftPadWord256(makeBytes(20)),
}
account2 := &Account{
Address: LeftPadWord256(makeBytes(20)),
}
st.accounts[account1.Address.String()] = account1
st.accounts[account2.Address.String()] = account2
ourVm := NewVM(st, newParams(), Zero256, nil)
var gas uint64 = 1000
code_parts := []string{"620f42403355",
"7c0100000000000000000000000000000000000000000000000000000000",
"600035046315cf268481141561004657",
"6004356040526040515460605260206060f35b63693200ce81141561008757",
"60043560805260243560a052335460c0523360e05260a05160c05112151561008657",
"60a05160c0510360e0515560a0516080515401608051555b5b505b6000f3"}
code, _ := hex.DecodeString(strings.Join(code_parts, ""))
fmt.Printf("Code: %x\n", code)
data, _ := hex.DecodeString("693200CE0000000000000000000000004B4363CDE27C2EB05E66357DB05BC5C88F850C1A0000000000000000000000000000000000000000000000000000000000000005")
output, err := ourVm.Call(account1, account2, code, data, 0, &gas)
fmt.Printf("Output: %v Error: %v\n", output, err)
if err != nil {
t.Fatal(err)
}
}
func download(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
key, err := hex.DecodeString(r.Form["key"][0])
if err != nil {
logging.Println(err.Error())
return
}
fhash := r.URL.Path[len("/MetaDisk/api/download/"):]
filehash, err := hex.DecodeString(fhash)
if err != nil {
logging.Println(err.Error())
return
}
logging.Print(key)
logging.Print(filehash)
// f, err := os.Open("rand.dat")
// if err != nil {
// logging.Println(err.Error())
// return
// }
// fi, err := f.Stat()
// if err != nil {
// logging.Println(err.Error())
// return
// }
// rh := newRetrieveandler(b, fi.Size())
// telehash.OpenChannel(loc, "retrieving", rh)
}
func decryptKeyV1(keyProtected *encryptedKeyJSONV1, auth string) (keyBytes []byte, keyId []byte, err error) {
keyId = uuid.Parse(keyProtected.Id)
mac, err := hex.DecodeString(keyProtected.Crypto.MAC)
if err != nil {
return nil, nil, err
}
iv, err := hex.DecodeString(keyProtected.Crypto.CipherParams.IV)
if err != nil {
return nil, nil, err
}
cipherText, err := hex.DecodeString(keyProtected.Crypto.CipherText)
if err != nil {
return nil, nil, err
}
derivedKey, err := getKDFKey(keyProtected.Crypto, auth)
if err != nil {
return nil, nil, err
}
calculatedMAC := Sha3(derivedKey[16:32], cipherText)
if !bytes.Equal(calculatedMAC, mac) {
return nil, nil, errors.New("Decryption failed: MAC mismatch")
}
plainText, err := aesCBCDecrypt(Sha3(derivedKey[:16])[:16], cipherText, iv)
if err != nil {
return nil, nil, err
}
return plainText, keyId, err
}
func ExampleNewGCMDecrypter() {
// The key argument should be the AES key, either 16 or 32 bytes
// to select AES-128 or AES-256.
key := []byte("AES256Key-32Characters1234567890")
ciphertext, _ := hex.DecodeString("f90fbef747e7212ad7410d0eee2d965de7e890471695cddd2a5bc0ef5da1d04ad8147b62141ad6e4914aee8c512f64fba9037603d41de0d50b718bd665f019cdcd")
nonce, _ := hex.DecodeString("bb8ef84243d2ee95a41c6c57")
block, err := aes.NewCipher(key)
if err != nil {
panic(err.Error())
}
aesgcm, err := cipher.NewGCM(block)
if err != nil {
panic(err.Error())
}
plaintext, err := aesgcm.Open(nil, nonce, ciphertext, nil)
if err != nil {
panic(err.Error())
}
fmt.Printf("%s\n", string(plaintext))
}
func Call(nodeAddr, pubkey, addr, toAddr, amtS, nonceS, gasS, feeS, data string) (*types.CallTx, error) {
pub, _, amt, nonce, err := checkCommon(nodeAddr, pubkey, addr, amtS, nonceS)
if err != nil {
return nil, err
}
toAddrBytes, err := hex.DecodeString(toAddr)
if err != nil {
return nil, fmt.Errorf("toAddr is bad hex: %v", err)
}
fee, err := strconv.ParseInt(feeS, 10, 64)
if err != nil {
return nil, fmt.Errorf("fee is misformatted: %v", err)
}
gas, err := strconv.ParseInt(gasS, 10, 64)
if err != nil {
return nil, fmt.Errorf("gas is misformatted: %v", err)
}
dataBytes, err := hex.DecodeString(data)
if err != nil {
return nil, fmt.Errorf("data is bad hex: %v", err)
}
tx := types.NewCallTxWithNonce(pub, toAddrBytes, dataBytes, amt, gas, fee, int(nonce))
return tx, nil
}
func addInvoice(ctx *cli.Context) error {
client := getClient(ctx)
preimage, err := hex.DecodeString(ctx.String("preimage"))
if err != nil {
return fmt.Errorf("unable to parse preimage: %v", err)
}
receipt, err := hex.DecodeString(ctx.String("receipt"))
if err != nil {
return fmt.Errorf("unable to parse receipt: %v", err)
}
invoice := &lnrpc.Invoice{
Memo: ctx.String("memo"),
Receipt: receipt,
RPreimage: preimage,
Value: int64(ctx.Int("value")),
}
resp, err := client.AddInvoice(context.Background(), invoice)
if err != nil {
return err
}
printRespJson(struct {
RHash string `json:"r_hash"`
}{
RHash: hex.EncodeToString(resp.RHash),
})
return nil
}
func TestAmqp_ChannelCloseErrorMethod(t *testing.T) {
if testing.Verbose() {
logp.LogInit(logp.LOG_DEBUG, "", false, true, []string{"amqp", "amqpdetailed"})
}
amqp := amqpModForTests()
data, err := hex.DecodeString("0100010000009000140028019685505245434f4e444" +
"954494f4e5f4641494c4544202d20696e6571756976616c656e74206172672027617574" +
"6f5f64656c6574652720666f722065786368616e676520277465737445786368616e676" +
"52720696e2076686f737420272f273a207265636569766564202774727565272062757" +
"42063757272656e74206973202766616c7365270028000ace")
assert.Nil(t, err)
data2, err := hex.DecodeString("0100010000000400280033ce")
assert.Nil(t, err)
tcptuple := testTCPTuple()
req := protos.Packet{Payload: data}
private := protos.ProtocolData(new(amqpPrivateData))
private = amqp.Parse(&req, tcptuple, 0, private)
req = protos.Packet{Payload: data2}
amqp.Parse(&req, tcptuple, 1, private)
trans := expectTransaction(t, amqp)
assert.Equal(t, "channel.close", trans["method"])
assert.Equal(t, "amqp", trans["type"])
assert.Equal(t, common.ERROR_STATUS, trans["status"])
assert.Nil(t, trans["notes"])
}
func TestEncrypt(t *testing.T) {
for _, c := range cases {
enc, encErr := hex.DecodeString(c.enc)
if encErr != nil {
t.Errorf("Error decoding hex: %v, %v", c.enc, encErr)
}
plain, plainErr := hex.DecodeString(c.plain)
if plainErr != nil {
t.Errorf("Error decoding hex: %v, %v", c.plain, plainErr)
}
encSalt, encSaltErr := hex.DecodeString(c.encSalt)
if encSaltErr != nil {
t.Errorf("Error decoding hex: %v, %v", c.encSalt, encSaltErr)
}
hmacSalt, hmacSaltErr := hex.DecodeString(c.hmacSalt)
if hmacSaltErr != nil {
t.Errorf("Error decoding hex: %v, %v", c.hmacSalt, hmacSaltErr)
}
iv, ivErr := hex.DecodeString(c.iv)
if ivErr != nil {
t.Errorf("Error decoding hex: %v, %v", c.iv, ivErr)
}
testEnc, testEncError := EncryptWithOptions(c.password, plain, encSalt, hmacSalt, iv)
if testEncError != nil {
t.Errorf("Error encrypting: %v, %v", testEnc, testEncError)
}
if !bytes.Equal(testEnc, enc) {
t.Errorf("FAILED (%v) -> expected %v, got %v", c.title, enc, testEnc)
}
}
}
func TestAmqp_MultipleBodyFrames(t *testing.T) {
if testing.Verbose() {
logp.LogInit(logp.LOG_DEBUG, "", false, true, []string{"amqp", "amqpdetailed"})
}
amqp := amqpModForTests()
amqp.sendRequest = true
data, err := hex.DecodeString("0100010000000e003c00280000000568656c6c6f00ce" +
"02000100000021003c0000000000000000002a80400a746578742f706c61696e00000000" +
"56a22873ce030001000000202a2a2a68656c6c6f2049206c696b6520746f207075626c69" +
"736820626967206dce")
assert.Nil(t, err)
data2, err := hex.DecodeString("0300010000000a657373616765732a2a2ace")
assert.Nil(t, err)
tcptuple := testTCPTuple()
req := protos.Packet{Payload: data}
private := protos.ProtocolData(new(amqpPrivateData))
private = amqp.Parse(&req, tcptuple, 0, private)
req = protos.Packet{Payload: data2}
amqp.Parse(&req, tcptuple, 0, private)
trans := expectTransaction(t, amqp)
assert.Equal(t, "basic.publish", trans["method"])
assert.Equal(t, "***hello I like to publish big messages***", trans["request"])
}
func TestGenPostHandler(t *testing.T) {
pubKey, _ := hex.DecodeString("39d8913ab046428e409cf1fa7cee6f63c1f6bf701356a44a8c8c2559bdb2526f")
privKey, _ := hex.DecodeString("20a2633e422090a4f4a102f8e3d112f2b4378dbd9957e8c892067fc09239d36c39d8913ab046428e409cf1fa7cee6f63c1f6bf701356a44a8c8c2559bdb2526f")
log.SetMinLevel(log.LevelDebug)
testDir := path.Join(os.TempDir(), "repbin")
if err := os.MkdirAll(testDir, 0700); err != nil {
t.Fatal(err)
}
ms, err := New(testDir+string(os.PathSeparator), pubKey, privKey)
if err != nil {
t.Fatalf("New: %s", err)
}
enforceTimeOuts = false
debug = true
ms.NotifyDuration = 0
ms.FetchDuration = 0
ms.LoadPeers()
ms.NotifyPeers()
ms.FetchPeers()
http.HandleFunc("/id", ms.ServeID)
http.HandleFunc("/keyindex", ms.GetKeyIndex)
http.HandleFunc("/globalindex", ms.GetGlobalIndex)
http.HandleFunc("/post", ms.GenPostHandler(false))
http.HandleFunc("/local/post", ms.GenPostHandler(true))
http.HandleFunc("/fetch", ms.Fetch)
http.HandleFunc("/notify", ms.GetNotify)
http.HandleFunc("/delete", ms.Delete)
go http.ListenAndServe(":8080", nil)
time.Sleep(time.Second / 100)
if !testing.Short() {
// only necessary for long test in getpost_test.go
time.Sleep(time.Second * 10)
}
}
func TestAmqp_GetMethod(t *testing.T) {
if testing.Verbose() {
logp.LogInit(logp.LOG_DEBUG, "", false, true, []string{"amqp", "amqpdetailed"})
}
amqp := amqpModForTests()
amqp.sendRequest = true
amqp.sendResponse = true
data, err := hex.DecodeString("0100010000000f003c0046000007546573744" +
"7657401ce")
assert.Nil(t, err)
data2, err := hex.DecodeString("0100010000001a003c00470000000000000001" +
"0000075465737447657400000001ce02000100000019003c000000000000000000" +
"1280000a746578742f706c61696ece03000100000012476574206d6520696620796" +
"f752064617265ce")
assert.Nil(t, err)
tcptuple := testTCPTuple()
req := protos.Packet{Payload: data}
private := protos.ProtocolData(new(amqpPrivateData))
private = amqp.Parse(&req, tcptuple, 0, private)
req = protos.Packet{Payload: data2}
amqp.Parse(&req, tcptuple, 1, private)
trans := expectTransaction(t, amqp)
assert.Equal(t, "basic.get", trans["method"])
assert.Equal(t, "basic.get TestGet", trans["request"])
assert.Equal(t, "amqp", trans["type"])
assert.Equal(t, common.OK_STATUS, trans["status"])
assert.Equal(t, "Get me if you dare", trans["response"])
}
// This example demonstrates decrypting a message using a private key that is
// first parsed from raw bytes.
func Example_decryptMessage() {
// Decode the hex-encoded private key.
pkBytes, err := hex.DecodeString("a11b0a4e1a132305652ee7a8eb7848f6ad" +
"5ea381e3ce20a2c086a2e388230811")
if err != nil {
fmt.Println(err)
return
}
privKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), pkBytes)
ciphertext, err := hex.DecodeString("35f644fbfb208bc71e57684c3c8b437402ca" +
"002047a2f1b38aa1a8f1d5121778378414f708fe13ebf7b4a7bb74407288c1958969" +
"00207cf4ac6057406e40f79961c973309a892732ae7a74ee96cd89823913b8b8d650" +
"a44166dc61ea1c419d47077b748a9c06b8d57af72deb2819d98a9d503efc59fc8307" +
"d14174f8b83354fac3ff56075162")
// Try decrypting the message.
plaintext, err := btcec.Decrypt(privKey, ciphertext)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(plaintext))
// Output:
// test message
}
func newCommitChain() *CommitChainMsg {
msg := new(CommitChainMsg)
cc := entryCreditBlock.NewCommitChain()
cc.Version = 0x11
cc.MilliTime = (*primitives.ByteSlice6)(&[6]byte{1, 1, 1, 1, 1, 1})
p, _ := hex.DecodeString("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
cc.ChainIDHash.SetBytes(p)
p, _ = hex.DecodeString("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
cc.Weld.SetBytes(p)
p, _ = hex.DecodeString("cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc")
cc.EntryHash.SetBytes(p)
cc.Credits = 11
// make a key and sign the msg
if pub, privkey, err := ed.GenerateKey(rand.Reader); err != nil {
panic(err)
} else {
cc.ECPubKey = (*primitives.ByteSlice32)(pub)
cc.Sig = (*primitives.ByteSlice64)(ed.Sign(privkey, cc.CommitMsg()))
}
msg.CommitChain = cc
//msg.Timestamp = primitives.NewTimestampNow()
return msg
}
func blobValidation(t *testing.T, test blobTest, result blobFinalizer, m BlobStorage) {
key := strings.Replace(test.key, " ", "", -1)
bid := strings.Replace(test.bid, " ", "", -1)
rbid, rkey, err := result.Finalize()
if err != nil {
t.Error(err)
}
if rbid != bid {
t.Errorf("Invalid blob id generated, got: %v..., expected: %v...", rbid[:16], bid[:16])
}
if rkey != key {
t.Errorf("Invalid key generated, got: %v..., expected: %v...", rkey[:16], key[:16])
}
reader, err := m.NewBlobReader(rbid)
if err != nil {
t.Errorf("Couldn't open the blob with id: %v... for reading: %v", rbid[:16], err)
} else {
readBytes, err := ioutil.ReadAll(reader)
if err != nil {
t.Errorf("Couldn't read the blob with id: %v..., error: %v", rbid[:16], err)
} else {
blobHex := strings.Replace(test.blobHex, " ", "", -1)
splitPos := strings.Index(blobHex, "...")
if splitPos >= 0 {
dataBefore, _ := hex.DecodeString(blobHex[:splitPos])
dataAfter, _ := hex.DecodeString(blobHex[splitPos+3:])
if !bytes.Equal(readBytes[:len(dataBefore)], dataBefore) {
t.Errorf("The blob with id: %v... has invalid content (starting bytes), got: %v, expected %v",
rbid[:16],
hexDump(readBytes),
hexDump(dataBefore))
}
if !bytes.Equal(readBytes[len(readBytes)-len(dataAfter):], dataAfter) {
t.Errorf("The blob with id: %v... has invalid content (ending bytes), got: %v, expected %v",
rbid[:16],
hexDump(readBytes[len(readBytes)-len(dataAfter):]),
hexDump(dataAfter))
}
} else {
blob, _ := hex.DecodeString(blobHex)
if !bytes.Equal(readBytes, blob) {
t.Errorf("The blob with id: %v... has invalid content, got: %v, expected %v",
rbid[:16],
hexDump(readBytes),
hexDump(blob))
}
}
}
}
}