Beispiel #1
0
// Compile instruction
//
// Attempts to compile and parse the given instruction in "s"
// and returns the byte sequence
func CompileInstr(s interface{}) ([]byte, error) {
	switch s.(type) {
	case string:
		str := s.(string)
		isOp := IsOpCode(str)
		if isOp {
			return []byte{OpCodes[str]}, nil
		}

		// Check for pre formatted byte array
		// Jumps are preformatted
		if []byte(str)[0] == 0 {
			return []byte(str), nil
		}

		num := new(big.Int)
		_, success := num.SetString(str, 0)
		// Assume regular bytes during compilation
		if !success {
			num.SetBytes([]byte(str))
		}

		return num.Bytes(), nil
	case int:
		//num := bigToBytes(big.NewInt(int64(s.(int))), 256)
		return big.NewInt(int64(s.(int))).Bytes(), nil
	case []byte:
		return new(big.Int).SetBytes(s.([]byte)).Bytes(), nil
	}

	return nil, nil
}
Beispiel #2
0
func TestDecryptOAEP(t *testing.T) {
	random := rand.Reader

	sha1 := sha1.New()
	n := new(big.Int)
	d := new(big.Int)
	for i, test := range testEncryptOAEPData {
		n.SetString(test.modulus, 16)
		d.SetString(test.d, 16)
		private := new(PrivateKey)
		private.PublicKey = PublicKey{n, test.e}
		private.D = d

		for j, message := range test.msgs {
			out, err := DecryptOAEP(sha1, nil, private, message.out, nil)
			if err != nil {
				t.Errorf("#%d,%d error: %s", i, j, err)
			} else if !bytes.Equal(out, message.in) {
				t.Errorf("#%d,%d bad result: %#v (want %#v)", i, j, out, message.in)
			}

			// Decrypt with blinding.
			out, err = DecryptOAEP(sha1, random, private, message.out, nil)
			if err != nil {
				t.Errorf("#%d,%d (blind) error: %s", i, j, err)
			} else if !bytes.Equal(out, message.in) {
				t.Errorf("#%d,%d (blind) bad result: %#v (want %#v)", i, j, out, message.in)
			}
		}
		if testing.Short() {
			break
		}
	}
}
Beispiel #3
0
func main() {
	in, _ := os.Open("465.in")
	defer in.Close()
	out, _ := os.Create("465.out")
	defer out.Close()

	var s1, s2 string
	var op byte
	var i1, i2, i3 big.Int
	var maxInt = big.NewInt(math.MaxInt32)
	for {
		if _, err := fmt.Fscanf(in, "%s %c %s", &s1, &op, &s2); err != nil {
			break
		}
		fmt.Fprintf(out, "%s %c %s\n", s1, op, s2)
		i1.SetString(s1, 10)
		if i1.Cmp(maxInt) > 0 {
			fmt.Fprintln(out, "first number too big")
		}
		i2.SetString(s2, 10)
		if i2.Cmp(maxInt) > 0 {
			fmt.Fprintln(out, "second number too big")
		}
		if op == '+' {
			i3.Add(&i1, &i2)
		} else {
			i3.Mul(&i1, &i2)
		}
		if i3.Cmp(maxInt) > 0 {
			fmt.Fprintln(out, "result too big")
		}
	}
}
Beispiel #4
0
func main() {

	var iban string
	var r, s, t, st []string
	u := new(big.Int)
	v := new(big.Int)
	w := new(big.Int)

	iban = "GB82 TEST 1234 5698 7654 32"
	r = strings.Split(iban, " ")
	s = strings.Split(r[0], "")
	t = strings.Split(r[1], "")

	st = []string{strconv.Itoa(sCode[t[0]]),
		strconv.Itoa(sCode[t[1]]),
		strconv.Itoa(sCode[t[2]]),
		strconv.Itoa(sCode[t[3]]),
		strings.Join(r[2:6], ""),
		strconv.Itoa(sCode[s[0]]),
		strconv.Itoa(sCode[s[1]]),
		strings.Join(s[2:4], ""),
	}

	u.SetString(strings.Join(st, ""), 10)
	v.SetInt64(97)
	w.Mod(u, v)

	if w.Uint64() == 1 && lCode[strings.Join(s[0:2], "")] == len(strings.Join(r, "")) {
		fmt.Printf("IBAN %s looks good!\n", iban)
	} else {
		fmt.Printf("IBAN %s looks wrong!\n", iban)
	}
}
Beispiel #5
0
func q2() {
	n := new(big.Int)
	a := new(big.Int)
	asquared := new(big.Int)
	one := new(big.Int)
	x := new(big.Int)
	xsquared := new(big.Int)
	p := new(big.Int)
	q := new(big.Int)
	candidate := new(big.Int)

	n.SetString("648455842808071669662824265346772278726343720706976263060439070378797308618081116462714015276061417569195587321840254520655424906719892428844841839353281972988531310511738648965962582821502504990264452100885281673303711142296421027840289307657458645233683357077834689715838646088239640236866252211790085787877", 10)
	one.SetString("1", 10)

	a = mathutil.SqrtBig(n)
	for {
		a.Add(a, one)
		asquared.Mul(a, a)
		xsquared.Sub(asquared, n)
		x = mathutil.SqrtBig(xsquared)
		p.Sub(a, x)
		q.Add(a, x)
		if candidate.Mul(p, q).Cmp(n) == 0 {
			fmt.Println(p.String())
			break
		}
	}
}
func main() {
	var a, b string
	fmt.Scan(&a, &b)
	start := time.Now()
	/** SetString(a string,base int)-----将输入的字符串处理为BigInt
	** The base argument must be 0 or a value from 2 through MaxBase.
	** If the base is 0,the string prefix determines the actual conversion base.
	** A prefix of “0x” or “0X” selects base 16;
	** the “0” prefix selects base 8, and a “0b” or “0B” prefix selects
	** base 2. Otherwise the selected base is 10.
	** 例如:输入的字符串为"1234...",表示该字符串为10进制,base=10;
	**      输入的字符串为"0x10ac1...",表示该字符串为16进制,base=16
	**      base开始取0时,当输入的字符串为"0x101...",前缀为"0x",表示该字符串为16
	**      进制,所以base的实际值为16
	**/
	c := new(big.Int)
	d := new(big.Int)
	e := new(big.Int)
	c.SetString(a, 10)
	d.SetString(b, 10)
	e.Mul(c, d)
	fmt.Println(e)
	duration := time.Since(start)
	fmt.Printf(" %vms\n", duration.Seconds()*1000)
}
Beispiel #7
0
func main() {

	// Open file for read
	fd, err := os.Open("numbers.txt")
	chk(err)
	defer fd.Close()

	// Line by line reader
	scanner := bufio.NewScanner(fd)
	scanner.Split(bufio.ScanLines)

	// Use standart library - big Integers
	bigSum := new(big.Int)

	for scanner.Scan() {
		ns := scanner.Text()
		bigInt := new(big.Int)
		bigInt.SetString(ns, 10) // Convert readed decimal string to big.Int
		bigSum.Add(bigSum, bigInt)
	}

	answerString := bigSum.String()
	fmt.Println("Result:", answerString, len(answerString))
	fmt.Println("Answer:", answerString[0:10])
}
Beispiel #8
0
// makeDecimalFromMandE reconstructs the decimal from the mantissa M and
// exponent E.
func makeDecimalFromMandE(negative bool, e int, m []byte, tmp []byte) decimal.Decimal {
	// ±dddd.
	b := tmp[:0]
	if n := len(m)*2 + 1; cap(b) < n {
		b = make([]byte, 0, n)
	}
	if negative {
		b = append(b, '-')
	}
	for i, v := range m {
		t := int(v)
		if i == len(m) {
			t--
		}
		t /= 2
		b = append(b, byte(t/10)+'0', byte(t%10)+'0')
	}

	// We unsafely convert the []byte to a string to avoid the usual allocation
	// when converting to a string.
	bi := new(big.Int)
	bi, ok := bi.SetString(*(*string)(unsafe.Pointer(&b)), 10)
	if !ok {
		panic("could not set big.Int's string value")
	}

	exp := 2*e - len(b)
	if negative {
		exp++
	}

	return decimal.NewFromBigInt(bi, int32(exp))
}
Beispiel #9
0
func problem55() string {

	reverseBig := func(b *big.Int) *big.Int {
		str := b.String()
		lenStr := len(str)
		strRev := make([]rune, lenStr)
		for i, r := range str {
			strRev[lenStr-1-i] = r
		}

		bReversed := new(big.Int)
		bReversed.SetString(string(strRev), 10)
		return bReversed
	}

	count := 0
	const iMax, jMax = 10000, 51

	for i := 1; i < iMax; i++ {
		ib := NewBig(i)
		count++
		for j := 0; j < jMax; j++ {
			ib.Add(ib, reverseBig(ib)) // compute next Lychrel
			if IsBigPalindrome(ib) {
				count--
				break
			}
		}
	}
	return itoa(count)
}
Beispiel #10
0
func main() {
	in, _ := os.Open("10183.in")
	defer in.Close()
	out, _ := os.Create("10183.out")
	defer out.Close()

	var a, b string
	var n1, n2 big.Int
	l := len(p)
	for {
		if fmt.Fscanf(in, "%s%s", &a, &b); a == "0" && b == "0" {
			break
		}
		n1.SetString(a, 10)
		n2.SetString(b, 10)

		c := 0
		for i := 1; i < l; i++ {
			if p[i].Cmp(&n1) >= 0 && p[i].Cmp(&n2) <= 0 {
				c++
			}
			if p[i].Cmp(&n2) > 0 {
				break
			}
		}
		fmt.Fprintln(out, c)
	}
}
Beispiel #11
0
// NewFromString returns a new Decimal from a string representation.
//
// Example:
//
//     d, err := NewFromString("-123.45")
//     d2, err := NewFromString(".0001")
//
func NewFromString(value string) (Decimal, error) {
	var intString string
	var exp int32
	parts := strings.Split(value, ".")
	if len(parts) == 1 {
		// There is no decimal point, we can just parse the original string as
		// an int
		intString = value
		exp = 0
	} else if len(parts) == 2 {
		intString = parts[0] + parts[1]
		expInt := -len(parts[1])
		if expInt < math.MinInt32 {
			// NOTE(vadim): I doubt a string could realistically be this long
			return Decimal{}, fmt.Errorf("can't convert %s to decimal: fractional part too long", value)
		}
		exp = int32(expInt)
	} else {
		return Decimal{}, fmt.Errorf("can't convert %s to decimal: too many .s", value)
	}

	dValue := new(big.Int)
	_, ok := dValue.SetString(intString, 10)
	if !ok {
		return Decimal{}, fmt.Errorf("can't convert %s to decimal", value)
	}

	return Decimal{
		value: dValue,
		exp:   exp,
	}, nil
}
Beispiel #12
0
// MakeConst makes an ideal constant from a literal
// token and the corresponding literal string.
func MakeConst(tok token.Token, lit string) Const {
	switch tok {
	case token.INT:
		var x big.Int
		_, ok := x.SetString(lit, 0)
		assert(ok)
		return Const{&x}
	case token.FLOAT:
		var y big.Rat
		_, ok := y.SetString(lit)
		assert(ok)
		return Const{&y}
	case token.IMAG:
		assert(lit[len(lit)-1] == 'i')
		var im big.Rat
		_, ok := im.SetString(lit[0 : len(lit)-1])
		assert(ok)
		return Const{cmplx{big.NewRat(0, 1), &im}}
	case token.CHAR:
		assert(lit[0] == '\'' && lit[len(lit)-1] == '\'')
		code, _, _, err := strconv.UnquoteChar(lit[1:len(lit)-1], '\'')
		assert(err == nil)
		return Const{big.NewInt(int64(code))}
	case token.STRING:
		s, err := strconv.Unquote(lit)
		assert(err == nil)
		return Const{s}
	}
	panic("unreachable")
}
Beispiel #13
0
func TestJwksSerializationPadding(t *testing.T) {
	x := new(big.Int)
	y := new(big.Int)

	e := &EssentialHeader{}
	e.KeyType = jwa.EC
	x.SetString("123520477547912006148785171019615806128401248503564636913311359802381551887648525354374204836279603443398171853465", 10)
	y.SetString("13515585925570416130130241699780319456178918334914981404162640338265336278264431930522217750520011829472589865088261", 10)
	pubKey := &ecdsa.PublicKey{
		Curve: elliptic.P384(),
		X:     x,
		Y:     y,
	}
	jwkPubKey := NewEcdsaPublicKey(pubKey)
	jwkPubKey.EssentialHeader = e
	jwkJSON, err := json.Marshal(jwkPubKey)
	if !assert.NoError(t, err, "JWK Marshalled") {
		return
	}

	_, err = Parse(jwkJSON)
	if !assert.NoError(t, err, "JWK Parsed") {
		return
	}

}
func TestGenerateGUID(t *testing.T) {
	idReader = rand.New(rand.NewSource(0))

	for i := 0; i < 1000; i++ {
		guid := NewID()

		var i big.Int
		_, ok := i.SetString(guid, randomIDBase)
		if !ok {
			t.Fatal("id should be base 36", i, guid)
		}

		// To ensure that all identifiers are fixed length, we make sure they
		// get padded out to 25 characters, which is the maximum for the base36
		// representation of 128-bit identifiers.
		//
		// For academics,  f5lxx1zz5pnorynqglhzmsp33  == 2^128 - 1. This value
		// was calculated from floor(log(2^128-1, 36)) + 1.
		//
		// See http://mathworld.wolfram.com/NumberLength.html for more information.
		if len(guid) != maxRandomIDLength {
			t.Fatalf("len(%s) != %v", guid, maxRandomIDLength)
		}
	}
}
Beispiel #15
0
func main() {
	var s string
	var n, two, tmp big.Int
	two.SetInt64(2)

	in, _ := os.Open("10519.in")
	defer in.Close()
	out, _ := os.Create("10519.out")
	defer out.Close()

	for {
		if _, err := fmt.Fscanf(in, "%s", &s); err != nil {
			break
		}
		if s == "0" {
			fmt.Fprintln(out, 1)
			continue
		}
		n.SetString(s, 10)
		tmp.Mul(&n, &n)
		tmp.Sub(&tmp, &n)
		tmp.Add(&tmp, &two)
		fmt.Fprintln(out, &tmp)
	}
}
Beispiel #16
0
func HandleRegisterBasic(w http.ResponseWriter, r *http.Request) {
	fmt.Println("HandleRegisterBasic")
	tmpCurve := elliptic.P256()
	r.ParseMultipartForm(int64(100))
	step := strings.TrimSpace(r.PostFormValue("step"))
	//state := strings.TrimSpace(r.PostFormValue("state"))
	if step == "0" {
		//fmt.Println(step, ":", state)
		w.Header().Set("Content-Type", "application/json")
		preInfo, _ := json.Marshal(PreInfo{tmpCurve.Params().Gx.String(), tmpCurve.Params().Gy.String(), tmpCurve.Params().P.String(), tmpCurve.Params().B.String(), tmpCurve.Params().N.String()})
		//fmt.Println(string(preInfo))
		io.WriteString(w, string(preInfo))
	}
	if step == "1" {
		//fmt.Println(step, "::", state)
		pubKey := strings.TrimSpace(r.PostFormValue("pub_key"))
		fmt.Println(pubKey)
		uname := strings.TrimSpace(r.PostFormValue("uname"))
		key := strings.Split(pubKey, ",")
		pX := new(big.Int)
		pY := new(big.Int)
		pX.SetString(key[0], 10)
		pY.SetString(key[1], 10)
		dataB = elliptic.Marshal(tmpCurve, pX, pY)
		fmt.Println(">>>>>>>", uname)
		fmt.Println(">>>>>>>", dataB)

		storeData(uname, dataB)
		_, _ = getData(uname)
	}
}
Beispiel #17
0
// Converts a number to a binary byte slice
// i.e. 4 => [0,0,0,4]
// 256 => [0,0,1,0]
// or in the case of 64
// 4 = > [0,0,0,0,0,0,0,4]
func makeBinary(value interface{}) []byte {
	var z []byte
	var val uint64

	amount := 4

	if v, ok := value.(uint64); ok {
		amount = 8
		val = v
	} else if v, ok := value.(uint32); ok {
		val = uint64(v)
	} else {
		log.Panic("makeBinary requires a value that's either a uint32 or an uint64, got:", value)
	}

	str := strconv.FormatUint(val, 10)

	number := new(big.Int)
	number.SetString(str, 10)

	template := make([]byte, amount)

	x := number.Bytes()
	z = append(template[:(amount-len(x))], x...)

	return z
}
Beispiel #18
0
func (n *Number) UnmarshalJSON(data []byte) error {
	input := strings.TrimSpace(string(data))

	if len(input) >= 2 && input[0] == '"' && input[len(input)-1] == '"' {
		input = input[1 : len(input)-1]
	}

	if len(input) == 0 {
		*n = Number(latestBlockNumber.Int64())
		return nil
	}

	in := new(big.Int)
	_, ok := in.SetString(input, 0)

	if !ok { // test if user supplied string tag
		return fmt.Errorf(`invalid number %s`, data)
	}

	if in.Cmp(earliestBlockNumber) >= 0 && in.Cmp(maxBlockNumber) <= 0 {
		*n = Number(in.Int64())
		return nil
	}

	return fmt.Errorf("blocknumber not in range [%d, %d]", earliestBlockNumber, maxBlockNumber)
}
Beispiel #19
0
func (d *decoder) parse_int_interface() (ret interface{}) {
	start := d.offset - 1
	d.read_until('e')
	if d.buf.Len() == 0 {
		panic(&SyntaxError{
			Offset: start,
			What:   errors.New("empty integer value"),
		})
	}

	n, err := strconv.ParseInt(d.buf.String(), 10, 64)
	if ne, ok := err.(*strconv.NumError); ok && ne.Err == strconv.ErrRange {
		i := new(big.Int)
		_, ok := i.SetString(d.buf.String(), 10)
		if !ok {
			panic(&SyntaxError{
				Offset: start,
				What:   errors.New("failed to parse integer"),
			})
		}
		ret = i
	} else {
		check_for_int_parse_error(err, start)
		ret = n
	}

	d.buf.Reset()
	return
}
Beispiel #20
0
// Test marshaling back and forth between string and int
// Pretty much a sanity check for further tests
func TestStringMarshal(t *testing.T) {
	for _, tc := range idTestCases {
		i := new(big.Int)
		i.SetString(tc.base10, 10)
		assert.Equal(t, tc.base10, i.String())
	}
}
Beispiel #21
0
func (s *MySuite) TestComplexStructWithNestingAndPointer(c *C) {
	reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
	c.Assert(err, IsNil)

	var result TestPointerType

	err = reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
	c.Assert(err, IsNil)

	c.Assert(*result.Array, DeepEquals, []uint{uint(1), uint(2), uint(3)})
	c.Assert(*result.Boolean, Equals, true)
	c.Assert(*result.Bytes, DeepEquals, []byte{0x00, 0x00, 0x00, 0x2a})
	c.Assert(*result.Double, Equals, 42.123456)
	c.Assert(*result.Float, Equals, float32(1.1))
	c.Assert(*result.Int32, Equals, int32(-268435456))

	c.Assert(result.Map.MapX.ArrayX, DeepEquals, []int{7, 8, 9})

	c.Assert(result.Map.MapX.UTF8StringX, Equals, "hello")

	c.Assert(*result.Uint16, Equals, uint16(100))
	c.Assert(*result.Uint32, Equals, uint32(268435456))
	c.Assert(**result.Uint64, Equals, uint64(1152921504606846976))
	c.Assert(*result.Utf8String, Equals, "unicode! ☯ - ♫")
	bigInt := new(big.Int)
	bigInt.SetString("1329227995784915872903807060280344576", 10)
	c.Assert(result.Uint128, DeepEquals, bigInt)

	c.Assert(reader.Close(), IsNil)
}
Beispiel #22
0
// Compile instruction
//
// Attempts to compile and parse the given instruction in "s"
// and returns the byte sequence
func CompileInstr(s interface{}) ([]byte, error) {
	switch s := s.(type) {
	case vm.OpCode:
		return []byte{byte(s)}, nil
	case string:
		str := s

		// Check for pre formatted byte array
		// Jumps are preformatted
		if []byte(str)[0] == 0 {
			return []byte(str), nil
		}

		num := new(big.Int)
		_, success := num.SetString(str, 0)
		// Assume regular bytes during compilation
		if !success {
			num.SetBytes([]byte(str))
		}

		return num.Bytes(), nil
	case int:
		return big.NewInt(int64(s)).Bytes(), nil
	case []byte:
		return new(big.Int).SetBytes(s).Bytes(), nil
	}

	return nil, nil
}
Beispiel #23
0
func CompileInstr(s interface{}) ([]byte, error) {
	switch s.(type) {
	case string:
		str := s.(string)
		isOp := IsOpCode(str)
		if isOp {
			return []byte{OpCodes[str]}, nil
		}

		num := new(big.Int)
		_, success := num.SetString(str, 0)
		// Assume regular bytes during compilation
		if !success {
			num.SetBytes([]byte(str))
		}

		return num.Bytes(), nil
	case int:
		return big.NewInt(int64(s.(int))).Bytes(), nil
	case []byte:
		return BigD(s.([]byte)).Bytes(), nil
	}

	return nil, nil
}
func TestNewSession(t *testing.T) {
	gp, err := GetGroupParameters(1024)
	if err != nil {
		t.Error(err)
	}

	config := new(SRPConfig).New(gp, testh, testgen)
	config.abgen = testagen
	sess, err := new(SRPClientSession).New("alice", config)

	if err != nil {
		t.Error(err)
	}

	var biga big.Int
	biga.SetString("61D5E490F6F1B79547B0704C436F523DD0E560F0C64115BB72557EC44352E8903211C04692272D8B2D1A5358A2CF1B6E0BFCF99F921530EC8E39356179EAE45E42BA92AEACED825171E1E8B9AF6D9C03E1327F44BE087EF06530E69F66615261EEF54073CA11CF5858F0EDFDFE15EFEAB349EF5D76988A3672FAC47B0769447B", 16)

	if !bytes.Equal(biga.Bytes(), sess.biga.Bytes()) {
		t.Errorf("Public ephemeral value A incorrect.\n Expected: %X\n Got: %X", biga.Bytes(), sess.biga.Bytes())
	}

	if sess.i != "alice" {
		t.Error("Username not correctly set.")
	}

	sess, err = new(SRPClientSession).New("", config)
	if err == nil {
		t.Error("Not properly reporting error on empty username.")
	}
}
Beispiel #25
0
// ParseDecimal returns a new Decimal from a string representation.
//
// Example:
//
//     d, err := ParseDecimal("-123.45")
//     d2, err := ParseDecimal(".0001")
//
func ParseDecimal(value string) (Decimal, error) {
	var intString string
	var exp int32
	parts := strings.Split(value, ".")
	if len(parts) == 1 {
		// There is no decimal point, we can just parse the original string as
		// an int.
		intString = value
		exp = 0
	} else if len(parts) == 2 {
		intString = parts[0] + parts[1]
		expInt := -len(parts[1])
		exp = int32(expInt)
	} else {
		return Decimal{}, fmt.Errorf("can't convert %s to decimal: too many .s", value)
	}

	dValue := new(big.Int)
	_, ok := dValue.SetString(intString, 10)
	if !ok {
		return Decimal{}, fmt.Errorf("can't convert %s to decimal", value)
	}

	val := Decimal{
		value:      dValue,
		exp:        exp,
		fracDigits: fracDigitsDefault(exp),
	}
	if exp < -MaxFractionDigits {
		val = val.rescale(-MaxFractionDigits)
	}
	return val, nil
}
Beispiel #26
0
// Tests v.New() with a simple hash function and a given salt
// checks output with test vector from appendix of RFC 5054
func TestSimpleHashSalt(t *testing.T) {
	testgp, err := GetGroupParameters(1024)

	if err != nil {
		t.Error("Error: ", err)
	}

	config := new(SRPConfig).New(testgp, testh, testgen)
	_, err = v.New("alice", "alice:password123", 32, config)
	if err == nil {
		t.Logf("Verifier is %X.\nSalt is %X.\n", v.Verifier.Bytes(), v.Salt.Bytes())
	} else {
		t.Error("Error: ", err)
	}

	var correctv, corrects big.Int
	correctv.SetString("7E273DE8696FFC4F4E337D05B4B375BEB0DDE1569E8FA00A9886D8129BADA1F1822223CA1A605B530E379BA4729FDC59F105B4787E5186F5C671085A1447B52A48CF1970B4FB6F8400BBF4CEBFBB168152E08AB5EA53D15C1AFF87B2B9DA6E04E058AD51CC72BFC9033B564E26480D78E955A5E29E7AB245DB2BE315E2099AFB", 16)
	corrects.SetString("BEB25379D1A8581EB5A727673A2441EE", 16)

	if !bytes.Equal(correctv.Bytes(), v.Verifier.Bytes()) {
		t.Errorf("Error: Incorrect verifier.\nExpected: %X\nGot: %X", correctv.Bytes(), v.Verifier.Bytes())
	}

	if !bytes.Equal(corrects.Bytes(), v.Salt.Bytes()) {
		t.Error("Error: recieved incorrect salt.")
	}

	if v.I != "alice" {
		t.Errorf("Error: username should be set to alice. Got %v", v.I)
	}
}
Beispiel #27
0
// Generates and opens a temporary file with a defined prefix and suffix
// This is the same api as ioutil.TempFile accept it accepts a suffix
//  TODO: see if this is too slow
func TempFile(dir, prefix string, suffix string) (f *os.File, err error) {
	if dir == "" {
		dir = os.TempDir()
	}

	// The maximum size of random file count
	// TODO: see if we can do this at package scope somehow
	var maxRand *big.Int = big.NewInt(0)
	maxRand.SetString("FFFFFFFFFFFFFFFF", 16)

	var randNum *big.Int

	for i := 0; i < 10000; i++ {
		// Generate random part of the path name
		randNum, err = rand.Int(rand.Reader, maxRand)

		if err != nil {
			return
		}

		// Transform to an int
		randString := hex.EncodeToString(randNum.Bytes())

		// Attempt to open file and fail if it already exists
		name := filepath.Join(dir, prefix+randString+suffix)
		f, err = os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
		if os.IsExist(err) {
			continue
		}
		break
	}
	return
}
// finishReadingInteger tries parsing an int64, then a uint64, and finally a big.Int,
// as required by the size of the value.
func finishReadingInteger(xmlDecoder *xml.Decoder) (interface{}, error) {
	raw, err := readCharDataUntilEnd(xmlDecoder, integerStartElement.End())
	if err != nil {
		return nil, err
	}

	var value interface{}
	value, err = strconv.ParseInt(raw, 10, 64)
	if err == nil {
		return value, nil
	} else if !isErrOutOfRange(err) {
		return nil, err
	}

	value, err = strconv.ParseUint(raw, 10, 64)
	if err == nil {
		return value, nil
	} else if !isErrOutOfRange(err) {
		return nil, err
	}

	var bigValue big.Int
	if _, ok := bigValue.SetString(raw, 10); ok {
		return bigValue, nil
	}

	return nil, fmt.Errorf("Could not parse '%s' as an integer.", raw)
}
Beispiel #29
0
func str2big(hex string) *big.Int {
	var x big.Int
	_, ok := x.SetString(hex, 16)
	if !ok {
		panic("FOO")
	}
	return &x
}
Beispiel #30
0
func bigIntFromStr(s string, base int) *big.Int {
	result := new(big.Int)
	result, success := result.SetString(s, 10)
	if !success {
		die(false, "Error: cannot create big int from string '%s'", s)
	}
	return result
}