LBRYCommunity/lbryschema.go
1
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity

formatting and imports

Browse source
This commit is contained in:
Jack Robison 2018-02-15 14:51:51 -05:00
parent cdaf3ac682
commit dd814b834b
No known key found for this signature in database
GPG key ID: DF25C68FE0239BB2
13 changed files with 75 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
address/base58/character.go
View file

@ -5,7 +5,7 @@ import (
"math/big" "math/big"
) )
var b58_characters = [58]byte{0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, var b58Characters = [58]byte{0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45,
0x46, 0x47, 0x48, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x46, 0x47, 0x48, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
@ -13,7 +13,7 @@ var b58_characters = [58]byte{0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x
func CharacterIndex(character byte) (*big.Int, error) { func CharacterIndex(character byte) (*big.Int, error) {
for i := 0; i < 58; i++ { for i := 0; i < 58; i++ {
if b58_characters[i] == character { if b58Characters[i] == character {
return big.NewInt(int64(i)), nil return big.NewInt(int64(i)), nil
} }
} }

8
address/base58/checksum.go
View file

@ -2,14 +2,14 @@ package base58
import "crypto/sha256" import "crypto/sha256"
const checksum_length = 4 const checksumLength = 4
func VerifyBase58Checksum(v []byte) bool { func VerifyBase58Checksum(v []byte) bool {
checksum := [checksum_length]byte{} checksum := [checksumLength]byte{}
for i := range checksum { for i := range checksum {
checksum[i] = v[len(v)-checksum_length+i] checksum[i] = v[len(v)-checksumLength+i]
} }
real_checksum := sha256.Sum256(v[:len(v)-checksum_length]) real_checksum := sha256.Sum256(v[:len(v)-checksumLength])
real_checksum = sha256.Sum256(real_checksum[:]) real_checksum = sha256.Sum256(real_checksum[:])
for i, c := range checksum { for i, c := range checksum {
if c != real_checksum[i] { if c != real_checksum[i] {

8
address/base58/decode.go
View file

@ -7,7 +7,7 @@ import (
func DecodeBase58(value string, size int64) ([]byte, error) { func DecodeBase58(value string, size int64) ([]byte, error) {
buf := []byte(value) buf := []byte(value)
long_value := big.NewInt(0) longValue := big.NewInt(0)
result := make([]byte, size) result := make([]byte, size)
for i := int64(len(buf) - 1); i >= 0; i-- { for i := int64(len(buf) - 1); i >= 0; i-- {
to_add := big.NewInt(0) to_add := big.NewInt(0)
@ -17,11 +17,11 @@ func DecodeBase58(value string, size int64) ([]byte, error) {
return result, err return result, err
} }
to_add = to_add.Mul(c, to_add) to_add = to_add.Mul(c, to_add)
long_value = long_value.Add(to_add, long_value) longValue = longValue.Add(to_add, longValue)
} }
for i := size - 1; i >= 0; i-- { for i := size - 1; i >= 0; i-- {
m := big.NewInt(0) m := big.NewInt(0)
long_value, m = long_value.DivMod(long_value, big.NewInt(256), m) longValue, m = longValue.DivMod(longValue, big.NewInt(256), m)
bs := m.Bytes() bs := m.Bytes()
if len(bs) == 0 { if len(bs) == 0 {
bs = append(bs, 0x00) bs = append(bs, 0x00)
@ -29,7 +29,7 @@ func DecodeBase58(value string, size int64) ([]byte, error) {
b := byte(bs[0]) b := byte(bs[0])
result[i] = b result[i] = b
} }
if long_value.Int64() != 0 { if longValue.Int64() != 0 {
return result, errors.New("cannot decode to the given size") return result, errors.New("cannot decode to the given size")
} }
if size != int64(len(result)) { if size != int64(len(result)) {

10
address/base58/encode.go
View file

@ -5,25 +5,25 @@ import (
) )
func EncodeBase58(data []byte) string { func EncodeBase58(data []byte) string {
long_value := big.NewInt(0) longValue := big.NewInt(0)
result := "" result := ""
for i := 0; i < len(data); i++ { for i := 0; i < len(data); i++ {
to_add := big.NewInt(0) to_add := big.NewInt(0)
to_add = to_add.Exp(big.NewInt(256), big.NewInt(int64(i)), to_add) to_add = to_add.Exp(big.NewInt(256), big.NewInt(int64(i)), to_add)
to_add = to_add.Mul(big.NewInt(int64(data[24-i])), to_add) to_add = to_add.Mul(big.NewInt(int64(data[24-i])), to_add)
long_value = long_value.Add(to_add, long_value) longValue = longValue.Add(to_add, longValue)
} }
i := 0 i := 0
for { for {
m := big.NewInt(0) m := big.NewInt(0)
long_value, m = long_value.DivMod(long_value, big.NewInt(58), m) longValue, m = longValue.DivMod(longValue, big.NewInt(58), m)
bs := m.Bytes() bs := m.Bytes()
if len(bs) == 0 { if len(bs) == 0 {
bs = append(bs, 0x00) bs = append(bs, 0x00)
} }
b := b58_characters[bs[0]] b := b58Characters[bs[0]]
result = string(b) + result result = string(b) + result
if long_value.Int64() == 0 { if longValue.Int64() == 0 {
break break
} }
i += 1 i += 1

10
address/decode.go
View file

@ -1,16 +1,16 @@
package address package address
import ( import (
"./base58"
"errors" "errors"
"github.com/lbryio/lbryschema.go/address/base58"
) )
func DecodeAddress(address string, blockchainName string) ([address_length]byte, error) { func DecodeAddress(address string, blockchainName string) ([addressLength]byte, error) {
decoded, err := base58.DecodeBase58(address, address_length) decoded, err := base58.DecodeBase58(address, addressLength)
if err != nil { if err != nil {
return [address_length]byte{}, errors.New("failed to decode") return [addressLength]byte{}, errors.New("failed to decode")
} }
buf := [address_length]byte{} buf := [addressLength]byte{}
for i, b := range decoded { for i, b := range decoded {
buf[i] = b buf[i] = b
} }

4
address/encode.go
View file

@ -1,10 +1,10 @@
package address package address
import ( import (
"./base58" "github.com/lbryio/lbryschema.go/address/base58"
) )
func EncodeAddress(address [address_length]byte, blockchainName string) (string, error) { func EncodeAddress(address [addressLength]byte, blockchainName string) (string, error) {
buf, err := ValidateAddress(address, blockchainName) buf, err := ValidateAddress(address, blockchainName)
if err != nil { if err != nil {
return "", err return "", err

56
address/validate.go
View file

@ -1,59 +1,59 @@
package address package address
import ( import (
"./base58"
"errors" "errors"
"github.com/lbryio/lbryschema.go/address/base58"
) )
const lbrycrd_main_pubkey_prefix = byte(85) const lbrycrdMainPubkeyPrefix = byte(85)
const lbrycrd_main_script_prefix = byte(122) const lbrycrdMainScriptPrefix = byte(122)
const lbrycrd_testnet_pubkey_prefix = byte(111) const lbrycrdTestnetPubkeyPrefix = byte(111)
const lbrycrd_testnet_script_prefix = byte(196) const lbrycrdTestnetScriptPrefix = byte(196)
const lbrycrd_regtest_pubkey_prefix = byte(111) const lbrycrdRegtestPubkeyPrefix = byte(111)
const lbrycrd_regtest_script_prefix = byte(196) const lbrycrdRegtestScriptPrefix = byte(196)
const prefix_length = 1 const prefixLength = 1
const pubkey_length = 20 const pubkeyLength = 20
const checksum_length = 4 const checksumLength = 4
const address_length = prefix_length + pubkey_length + checksum_length const addressLength = prefixLength + pubkeyLength + checksumLength
const lbrycrd_main = "lbrycrd_main" const lbrycrdMain = "lbrycrd_main"
const lbrycrd_testnet = "lbrycrd_testnet" const lbrycrdTestnet = "lbrycrd_testnet"
const lbrycrd_regtest = "lbrycrd_regtest" const lbrycrdRegtest = "lbrycrd_regtest"
var address_prefixes = map[string][2]byte{} var addressPrefixes = map[string][2]byte{}
func SetPrefixes() { func SetPrefixes() {
address_prefixes[lbrycrd_main] = [2]byte{lbrycrd_main_pubkey_prefix, lbrycrd_main_script_prefix} addressPrefixes[lbrycrdMain] = [2]byte{lbrycrdMainPubkeyPrefix, lbrycrdMainScriptPrefix}
address_prefixes[lbrycrd_testnet] = [2]byte{lbrycrd_testnet_pubkey_prefix, lbrycrd_testnet_script_prefix} addressPrefixes[lbrycrdTestnet] = [2]byte{lbrycrdTestnetPubkeyPrefix, lbrycrdTestnetScriptPrefix}
address_prefixes[lbrycrd_regtest] = [2]byte{lbrycrd_regtest_pubkey_prefix, lbrycrd_regtest_script_prefix} addressPrefixes[lbrycrdRegtest] = [2]byte{lbrycrdRegtestPubkeyPrefix, lbrycrdRegtestScriptPrefix}
} }
func PrefixIsValid(address [address_length]byte, blockchainName string) bool { func PrefixIsValid(address [addressLength]byte, blockchainName string) bool {
SetPrefixes() SetPrefixes()
prefix := address[0] prefix := address[0]
for _, addr_prefix := range address_prefixes[blockchainName] { for _, addrPrefix := range addressPrefixes[blockchainName] {
if addr_prefix == prefix { if addrPrefix == prefix {
return true return true
} }
} }
return false return false
} }
func PubKeyIsValid(address [address_length]byte) bool { func PubKeyIsValid(address [addressLength]byte) bool {
pubkey := address[prefix_length : pubkey_length+prefix_length] pubkey := address[prefixLength : pubkeyLength+prefixLength]
// TODO: validate this for real // TODO: validate this for real
if len(pubkey) != pubkey_length { if len(pubkey) != pubkeyLength {
return false return false
} }
return true return true
} }
func AddressChecksumIsValid(address [address_length]byte) bool { func ChecksumIsValid(address [addressLength]byte) bool {
return base58.VerifyBase58Checksum(address[:]) return base58.VerifyBase58Checksum(address[:])
} }
func ValidateAddress(address [address_length]byte, blockchainName string) ([address_length]byte, error) { func ValidateAddress(address [addressLength]byte, blockchainName string) ([addressLength]byte, error) {
if blockchainName != lbrycrd_main && blockchainName != lbrycrd_testnet && blockchainName != lbrycrd_regtest { if blockchainName != lbrycrdMain && blockchainName != lbrycrdTestnet && blockchainName != lbrycrdRegtest {
return address, errors.New("invalid blockchain name") return address, errors.New("invalid blockchain name")
} }
if !PrefixIsValid(address, blockchainName) { if !PrefixIsValid(address, blockchainName) {
@ -62,7 +62,7 @@ func ValidateAddress(address [address_length]byte, blockchainName string) ([addr
if !PubKeyIsValid(address) { if !PubKeyIsValid(address) {
return address, errors.New("invalid pubkey") return address, errors.New("invalid pubkey")
} }
if !AddressChecksumIsValid(address) { if !ChecksumIsValid(address) {
return address, errors.New("invalid address checksum") return address, errors.New("invalid address checksum")
} }
return address, nil return address, nil

4
binding/lbryschema-python-binding.go
View file

@ -1,10 +1,10 @@
package main package main
import ( import (
"../address"
"../claim"
"C" "C"
"encoding/hex" "encoding/hex"
"github.com/lbryio/lbryschema.go/address"
"github.com/lbryio/lbryschema.go/claim"
) )
//export VerifySignature //export VerifySignature

4
claim/claim.go
View file

@ -1,8 +1,8 @@
package claim package claim
import ( import (
"../address" "github.com/lbryio/lbryschema.go/address"
"../pb" "github.com/lbryio/lbryschema.go/pb"
"encoding/hex" "encoding/hex"
"errors" "errors"
"github.com/golang/protobuf/jsonpb" "github.com/golang/protobuf/jsonpb"

13
claim/decode_test.go
View file

@ -17,27 +17,28 @@ func TestDecodeClaims(t *testing.T) {
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
serialized_hex, err := claim.SerializedHexString() serializedHex, err := claim.SerializedHexString()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
if serialized_hex != claim_hex { if serializedHex != claim_hex {
t.Error("failed to re-serialize") t.Error("failed to re-serialize")
} }
} }
} }
func TestStripSignature(t *testing.T) { func TestStripSignature(t *testing.T) {
claim_hex := raw_claims[1] claimHex := raw_claims[1]
claim, err := DecodeClaimHex(claim_hex, "lbrycrd_main") claim, err := DecodeClaimHex(claimHex, "lbrycrd_main")
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
no_sig, err := claim.SerializedNoSignature() noSig, err := claim.SerializedNoSignature()
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
if hex.EncodeToString(no_sig) != raw_claims[2] { if hex.EncodeToString(noSig) != raw_claims[2] {
t.Error("failed to remove signature") t.Error("failed to remove signature")
} }
} }

2
claim/serialization.go
View file

@ -1,7 +1,7 @@
package claim package claim
import ( import (
"../pb" "github.com/lbryio/lbryschema.go/pb"
"encoding/hex" "encoding/hex"
"errors" "errors"
"github.com/golang/protobuf/proto" "github.com/golang/protobuf/proto"

13
claim/validator.go
View file

@ -1,7 +1,6 @@
package claim package claim
import ( import (
"../address"
"crypto/ecdsa" "crypto/ecdsa"
"crypto/sha256" "crypto/sha256"
"crypto/x509/pkix" "crypto/x509/pkix"
@ -9,6 +8,7 @@ import (
"encoding/hex" "encoding/hex"
"errors" "errors"
"github.com/btcsuite/btcd/btcec" "github.com/btcsuite/btcd/btcec"
"github.com/lbryio/lbryschema.go/address"
"math/big" "math/big"
) )
@ -20,6 +20,9 @@ type publicKeyInfo struct {
const SECP256k1 = "SECP256k1" const SECP256k1 = "SECP256k1"
//const NIST256p = "NIST256p"
//const NIST384p = "NIST384p"
func GetClaimSignatureDigest(claimAddress [25]byte, certificateId [20]byte, serializedNoSig []byte) [32]byte { func GetClaimSignatureDigest(claimAddress [25]byte, certificateId [20]byte, serializedNoSig []byte) [32]byte {
var combined []byte var combined []byte
for _, c := range claimAddress { for _, c := range claimAddress {
@ -39,8 +42,8 @@ func (c *ClaimHelper) GetCertificatePublicKey() (*btcec.PublicKey, error) {
derBytes := c.GetCertificate().GetPublicKey() derBytes := c.GetCertificate().GetPublicKey()
pub := publicKeyInfo{} pub := publicKeyInfo{}
asn1.Unmarshal(derBytes, &pub) asn1.Unmarshal(derBytes, &pub)
pubkey_bytes := []byte(pub.PublicKey.Bytes) pubkeyBytes := []byte(pub.PublicKey.Bytes)
p, err := btcec.ParsePubKey(pubkey_bytes, btcec.S256()) p, err := btcec.ParsePubKey(pubkeyBytes, btcec.S256())
if err != nil { if err != nil {
return &btcec.PublicKey{}, err return &btcec.PublicKey{}, err
} }
@ -48,7 +51,7 @@ func (c *ClaimHelper) GetCertificatePublicKey() (*btcec.PublicKey, error) {
} }
func (c *ClaimHelper) VerifyDigest(certificate *ClaimHelper, signature [64]byte, digest [32]byte) bool { func (c *ClaimHelper) VerifyDigest(certificate *ClaimHelper, signature [64]byte, digest [32]byte) bool {
public_key, err := certificate.GetCertificatePublicKey() publicKey, err := certificate.GetCertificatePublicKey()
if err != nil { if err != nil {
return false return false
} }
@ -58,7 +61,7 @@ func (c *ClaimHelper) VerifyDigest(certificate *ClaimHelper, signature [64]byte,
S := &big.Int{} S := &big.Int{}
R.SetBytes(signature[0:32]) R.SetBytes(signature[0:32])
S.SetBytes(signature[32:64]) S.SetBytes(signature[32:64])
return ecdsa.Verify(public_key.ToECDSA(), digest[:], R, S) return ecdsa.Verify(publicKey.ToECDSA(), digest[:], R, S)
} }
return false return false
} }

10
cli/lbryschema-cli.go
View file

@ -1,16 +1,16 @@
package main package main
import ( import (
"../claim"
"fmt" "fmt"
"github.com/lbryio/lbryschema.go/claim"
"os" "os"
) )
func main() { func main() {
args := os.Args[1:] args := os.Args[1:]
if len(args) == 1 { if len(args) == 1 {
claim_bytes := []byte(args[0]) claimBytes := []byte(args[0])
decoded, err := claim.DecodeClaimBytes(claim_bytes, "lbrycrd_main") decoded, err := claim.DecodeClaimBytes(claimBytes, "lbrycrd_main")
if err != nil { if err != nil {
fmt.Println("Decoding error:", err) fmt.Println("Decoding error:", err)
return return
@ -23,8 +23,8 @@ func main() {
fmt.Println(text) fmt.Println(text)
return return
} else if (len(args) == 2) && (args[1] == "--decode_hex") { } else if (len(args) == 2) && (args[1] == "--decode_hex") {
claim_hex := args[0] claimHex := args[0]
decoded, err := claim.DecodeClaimHex(claim_hex, "lbrycrd_main") decoded, err := claim.DecodeClaimHex(claimHex, "lbrycrd_main")
if err != nil { if err != nil {
fmt.Println("Decoding error:", err) fmt.Println("Decoding error:", err)
return return