// Returns the base64 representation of the message after encryption with // the given key. The key is a word as used in gosa-si.conf whose md5sum will // be used as the actual AES key. // If msg == "", "" will be returned. func GosaEncrypt(msg string, key string) string { if msg == "" { return "" } aes, _ := aes.NewCipher([]byte(util.Md5sum(key))) crypter := cipher.NewCBCEncrypter(aes, config.InitializationVector) cyphertext := paddedMessage(msg) crypter.CryptBlocks(cyphertext, cyphertext) return string(util.Base64EncodeString(string(cyphertext))) }
func testHash() { f := xml.NewHash("fruit", "banana") check(f.Verify(), nil) check(f, "<fruit>banana</fruit>") f = xml.NewHash("fruit", "banana", "") check(f.Verify(), nil) check(f, "<fruit><banana></banana></fruit>") f = xml.NewHash("fruit", "yellow", "banana") check(f.Verify(), nil) check(f, "<fruit><yellow>banana</yellow></fruit>") f = xml.NewHash("fruit", "yellow", "long", "banana") check(f.Verify(), nil) check(f, "<fruit><yellow><long>banana</long></yellow></fruit>") f = xml.NewHash("fruit", "yellow", "long", "banana") yellow := f.First("yellow") f.First("yellow").Rename("green") check(f.Verify(), nil) check(f, "<fruit><green><long>banana</long></green></fruit>") check(yellow.Name(), "green") x := xml.NewHash("foo") check(f.Verify(), nil) check(x, "<foo></foo>") x.SetText(">Dıes ist ein >>>Test<<<<") check(x.String(), "<foo>>Dıes ist ein >>>Test<<<<</foo>") check(x.Text(), ">Dıes ist ein >>>Test<<<<") foo_haver := xml.NewHash("foo_haver") foo_haver.AddClone(x) check(foo_haver.Verify(), nil) check(x.Verify(), nil) check(foo_haver.Get("foo"), []string{">Dıes ist ein >>>Test<<<<"}) check(foo_haver.Text("foo"), ">Dıes ist ein >>>Test<<<<") check(foo_haver.Text(), "") check(foo_haver.String(), "<foo_haver><foo>>Dıes ist ein >>>Test<<<<</foo></foo_haver>") x.SetText("Dies ist %v %vter Test", "ein", 2) check(x, "<foo>Dies ist ein 2ter Test</foo>") bar := x.Add("bar") check(bar, "<bar></bar>") bar.Add("server", "srv1") check(x, "<foo>Dies ist ein 2ter Test<bar><server>srv1</server></bar></foo>") srv4 := bar.Add("server", "srv2") for _, s := range []string{"srv3", "srv4"} { srv4 = bar.Add("server", s) } check(x, "<foo>Dies ist ein 2ter Test<bar><server>srv1</server><server>srv2</server><server>srv3</server><server>srv4</server></bar></foo>") srv4.Add("alias", "foxtrott") srv4.Add("alias", "alpha") check(x, "<foo>Dies ist ein 2ter Test<bar><server>srv1</server><server>srv2</server><server>srv3</server><server>srv4<alias>foxtrott</alias><alias>alpha</alias></server></bar></foo>") x_clone := x.Clone() x_str := x.String() srv4.Add("alias", "bravo") check(x, "<foo>Dies ist ein 2ter Test<bar><server>srv1</server><server>srv2</server><server>srv3</server><server>srv4<alias>foxtrott</alias><alias>alpha</alias><alias>bravo</alias></server></bar></foo>") srv4.Add("alias", "delta") check(x, "<foo>Dies ist ein 2ter Test<bar><server>srv1</server><server>srv2</server><server>srv3</server><server>srv4<alias>foxtrott</alias><alias>alpha</alias><alias>bravo</alias><alias>delta</alias></server></bar></foo>") check(hash("a(b(c(d(x)))b(y)z)"), "<a>z<b><c><d>x</d></c></b><b>y</b></a>") lst := x.Get("foo") // x is a <foo> but contains no <foo> !! check(lst, []string{}) lst = x.Get() check(lst, []string{}) lst = x.Get("bar") check(lst, []string{bar.Text()}) lst = bar.Get("server") check(lst, []string{"srv1", "srv2", "srv3", srv4.Text()}) txt := srv4.Text("alias") check(txt, "foxtrott\u241ealpha\u241ebravo\u241edelta") txt = srv4.Text("alias", "doesnotexist") check(txt, "foxtrott\u241ealpha\u241ebravo\u241edelta") x.Add("max", "X") x.Add("moritz", "X") txt = x.Text("max", "moritz") check(txt, "X\u241eX") y, xmlerr := xml.StringToHash("<foo/><bar/>") check(y, "<bar></bar>") // last one wins check(xmlerr, "StringToHash(): Multiple top-level elements") y, xmlerr = xml.StringToHash("Nix gut") check(y, "<xml></xml>") // dummy returned if nothing properly parsed check(xmlerr, "StringToHash(): Stray text outside of tag: Nix gut") y, xmlerr = xml.StringToHash("<?xml version=\"1.0\"?><foo>We<bar>Hallo</bar>lt</foo>") check(y, "<foo>Welt<bar>Hallo</bar></foo>") check(xmlerr, "StringToHash(): Unsupported XML token: {xml [118 101 114 115 105 111 110 61 34 49 46 48 34]}") _, xmlerr = xml.StringToHash("<-foo></-foo>") check(xmlerr, "StringToHash(): XML syntax error on line 1: invalid XML name: -foo") y, xmlerr = xml.StringToHash("<foo bar=\"cool\"><drink more='yes' alcohol='sure'><sauf/></drink></foo>") check(y, "<foo><bar>cool</bar><drink><alcohol>sure</alcohol><more>yes</more><sauf></sauf></drink></foo>") check(xmlerr, nil) x_str2 := x.String() x_clone2 := x.AddClone(x) x_str3 := x.String() x_clone3 := x.AddClone(x) check(x_clone2, x_str2) check(x_clone3, x_str3) check(x.First("foo"), x_clone2) check(x.First("foo").Next(), x_clone3) check(x.First("foo").Next().First("foo"), x_clone2) check(x_clone, x_str) check(x_clone.Verify(), nil) check(x.Verify(), nil) check(x_clone2.Verify(), nil) check(x_clone3.Verify(), nil) broken := xml.NewHash("b0rken") var panic_err interface{} func() { defer func() { panic_err = recover() }() broken.AddWithOwnership(broken) }() check(panic_err, "AddWithOwnership: Sanity check failed!") panic_err = nil func() { defer func() { panic_err = recover() }() broken.AddWithOwnership(nil) }() check(panic_err, "AddWithOwnership: Sanity check failed!") panic_err = nil twin := broken.Add("twin") func() { defer func() { panic_err = recover() }() broken.AddWithOwnership(twin) }() check(panic_err, "AddWithOwnership: Sanity check failed!") panic_err = nil func() { defer func() { panic_err = recover() }() x.AddWithOwnership(x.First("foo")) }() check(panic_err, "AddWithOwnership: Sanity check failed!") family := xml.NewHash("family") mother := xml.NewHash("mother") mother.Add("abbr", "mom") father := xml.NewHash("father") father.Add("abbr", "dad") father.Add("abbr", "daddy") family.AddWithOwnership(mother) check(family.First("mother") == mother, true) family.AddWithOwnership(father) check(family.First("father") == father, true) mommy := xml.NewHash("abbr") mommy.SetText("mommy") mother.AddWithOwnership(mommy) mum := xml.NewHash("abbr") mum.SetText("mum") mother.AddWithOwnership(mum) mummy := xml.NewHash("abbr") mummy.SetText("mummy") mother.AddWithOwnership(mummy) check(mother.First("abbr").Next() == mommy, true) check(mommy.Next() == mum, true) check(mum.Next() == mummy, true) temp_mother := family.RemoveFirst("mother") check(temp_mother.Verify(), nil) family.AddWithOwnership(temp_mother) check(mother.RemoveFirst("not_present"), nil) mom := mother.First("abbr") mother.AddWithOwnership(mother.RemoveFirst("abbr")) check(mother.First("abbr") == mommy, true) check(mummy.Next() == mom, true) father.RemoveFirst("abbr") check(father.Text("abbr"), "daddy") check(mother.Get("abbr"), []string{"mommy", "mum", "mummy", "mom"}) check(family.Verify(), nil) ducks := xml.NewHash("ducks") dewey := ducks.Add("duck", "dewey") donald := ducks.Add("duck", "donald") first_removed_duck := ducks.RemoveFirst("duck") check(first_removed_duck == dewey, true) check(dewey.Verify(), nil) daisy := ducks.Add("duck", "daisy") darkwing := ducks.Add("duck", "darkwing") check(ducks.First("duck") == donald, true) check(donald.Next() == daisy, true) check(daisy.Next() == darkwing, true) check(darkwing.Next() == nil, true) check(ducks.Remove(&filterafter{darkwing}), "<ducks></ducks>") check(ducks.Remove(&filterafter{donald}).RemoveFirst("duck") == daisy, true) check(daisy.Verify(), nil) check(ducks.Verify(), nil) check(daisy.Next(), nil) check(ducks, "<ducks><duck>donald</duck><duck>darkwing</duck></ducks>") ducks.AddWithOwnership(daisy) check(ducks.Remove(&filterafter{darkwing}).First("duck") == daisy, true) check(daisy.Verify(), nil) check(daisy.Next(), nil) check(ducks.Verify(), nil) check(ducks.Remove(&filterafter{donald}).First("duck") == darkwing, true) check(darkwing.Verify(), nil) check(darkwing.Next(), nil) check(ducks.Verify(), nil) check(ducks, "<ducks><duck>donald</duck></ducks>") for num_kids := 1; num_kids < 5; num_kids++ { kids := xml.NewHash("kids") for i := 0; i < num_kids; i++ { kids.Add("kid", fmt.Sprintf("%d", i+1)) } test_kids := kids.Clone() check(test_kids.Verify(), nil) test_kid := test_kids.RemoveFirst("kid") if !check(test_kid.Verify(), nil) { fmt.Printf("FAILED for num_kids=%v\n", num_kids) } for i := 1; i < num_kids; i++ { test_kids = kids.Clone() test_kid = test_kids.First("kid") for j := 0; j < i; j++ { test_kid = test_kid.Next() } test_kid = test_kids.Remove(&filterafter{test_kid}).First("kid") check(test_kids.Verify(), nil) if i+1 == num_kids { check(test_kid, nil) } else { if !check(test_kid.Verify(), nil) { fmt.Printf("FAILED for num_kids=%v i=%v\n", num_kids, i) } } } } xyzzy := xml.NewHash("x") xyzzy.Add("y", "a") xyzzy.Add("y", "b") xyzzy.Add("y", "c") xyzzy.First("y").Add("A") xyzzy.First("y").Add("B") xyzzy.First("y").Add("C") xyzzy.First("y").Add("D") subtags := xyzzy.First("y").Subtags() sort.Strings(subtags) check(subtags, []string{"A", "B", "C", "D"}) xmlreader := bytes.NewBufferString("<xml>\n<foo>\nbar</foo>\n</xml>\x00Should be ignored\n") x, xmlerr = xml.ReaderToHash(xmlreader) check(xmlerr, "StringToHash(): XML syntax error on line 5: illegal character code U+0000") xmlreader = bytes.NewBufferString("<xml>\n<foo>\nbar</foo>\n</xml>") x, xmlerr = xml.ReaderToHash(xmlreader) check(xmlerr, nil) check(x, "<xml>\n\n<foo>\nbar</foo></xml>") x = xml.NewHash("xml") letters := "eacdb" for i := range letters { child := x.Add(letters[i : i+1]) for i := range letters { child.Add(letters[i : i+1]) } } check(x.Verify(), nil) check(x.String(), "<xml><a><a></a><b></b><c></c><d></d><e></e></a><b><a></a><b></b><c></c><d></d><e></e></b><c><a></a><b></b><c></c><d></d><e></e></c><d><a></a><b></b><c></c><d></d><e></e></d><e><a></a><b></b><c></c><d></d><e></e></e></xml>") x = xml.NewHash("foo") check(x.FirstOrAdd("id"), "<id></id>") x.FirstOrAdd("id").SetText("1") check(x.FirstOrAdd("id"), "<id>1</id>") check(x.FirstOrAdd("bar"), "<bar></bar>") x.Rename("foobar") check(x, "<foobar><bar></bar><id>1</id></foobar>") godzilla := xml.NewHash("monster", "godzilla") godzilla.Add("home", "japan") godzilla.AppendString(" junior") monsters := xml.NewHash("monsters") monsters.AddWithOwnership(godzilla) monsters.Add("monster", "gamera") godclone := godzilla.Clone() check(godclone.Verify(), nil) check(godzilla.Next(), "<monster>gamera</monster>") check(godclone.Next(), nil) check(godclone, "<monster>godzilla junior<home>japan</home></monster>") monsters.SetText("are cool") check(monsters, "<monsters>are cool<monster>godzilla junior<home>japan</home></monster><monster>gamera</monster></monsters>") monsters.First("monster").SetText("mecha-%v", monsters.Get("monster")[0]) check(monsters, "<monsters>are cool<monster>mecha-godzilla junior<home>japan</home></monster><monster>gamera</monster></monsters>") check(monsters.Verify(), nil) check(monsters.RemoveFirst("godzilla"), nil) check(monsters.Verify(), nil) check(monsters, "<monsters>are cool<monster>mecha-godzilla junior<home>japan</home></monster><monster>gamera</monster></monsters>") monsters.FirstOrAdd("creature").SetText("gollum") check(monsters.First("creature"), "<creature>gollum</creature>") check(godzilla.Next().Next(), nil) check(monsters.FirstChild().Element() == godzilla, true) check(monsters.FirstChild().Next().Element() == godzilla.Next(), true) st := monsters.Subtags() sort.Strings(st) check(st, []string{"creature", "monster"}) check(len(st), 2) x = xml.NewHash("foo") whole := []byte{} for n := 0; n <= 12; n++ { buf := make([]byte, n) for i := range buf { buf[i] = byte(i) } x.AppendString(string(buf)) whole = append(whole, buf...) } x.EncodeBase64() encoded := string(util.Base64EncodeString(string(whole))) check(x.Text(), encoded) x.DecodeBase64() check([]byte(x.Text()), whole) x.SetText() for i := range encoded { x.AppendString(string([]byte{encoded[i]})) } x.DecodeBase64() check([]byte(x.Text()), whole) x.SetText("H") x.EncodeBase64() check(x.Text(), "SA==") x.DecodeBase64() x.AppendString("a") x.EncodeBase64() check(x.Text(), "SGE=") x.DecodeBase64() x.AppendString("l") x.EncodeBase64() check(x.Text(), "SGFs") x.SetText("H") x.AppendString("a") x.EncodeBase64() check(x.Text(), "SGE=") x.SetText("H") x.AppendString("a") x.AppendString("l") x.EncodeBase64() check(x.Text(), "SGFs") x.SetText("H") x.AppendString("a") x.AppendString("l") x.AppendString("l") x.EncodeBase64() check(x.Text(), "SGFsbA==") x.SetText("H") x.AppendString("a") x.AppendString("l") x.AppendString("l") x.AppendString("o") x.EncodeBase64() check(x.Text(), "SGFsbG8=") x.SetText("Ha") x.AppendString("ll") x.AppendString("o") x.EncodeBase64() check(x.Text(), "SGFsbG8=") x.SetText("S") x.AppendString("G") x.AppendString("Fs") x.AppendString("b") x.AppendString("G8") x.DecodeBase64() check(x.Text(), "Hallo") testLDIF() }
func testBase64() { check(util.Base64DecodeString("", nil), []byte{}) check(util.Base64DecodeInPlace([]byte{}), []byte{}) check(util.Base64DecodeString("=", nil), []byte{}) check(util.Base64DecodeInPlace([]byte("=")), []byte{}) check(util.Base64DecodeString(" = ", nil), []byte{}) check(util.Base64DecodeInPlace([]byte(" = ")), []byte{}) check(util.Base64DecodeString("/+/+", nil), []byte{0xff, 0xef, 0xfe}) check(util.Base64DecodeInPlace([]byte("/+/+")), []byte{0xff, 0xef, 0xfe}) check(util.Base64DecodeString("_-_-", nil), []byte{0xff, 0xef, 0xfe}) check(util.Base64DecodeInPlace([]byte("_-_-")), []byte{0xff, 0xef, 0xfe}) var devnull int check(string(util.Base64DecodeString("SGFsbG8=", nil)), "Hallo") check(string(util.Base64DecodeInPlace([]byte("SGFsbG8="))), "Hallo") check(string(util.Base64DecodeString("SGFsbA==", nil)), "Hall") check(string(util.Base64DecodeInPlace([]byte("SGFsbA=="))), "Hall") check(string(util.Base64DecodeString("SGFsbG8", nil)), "Hallo") check(string(util.Base64DecodeInPlace([]byte("SGFsbG8"))), "Hallo") check(string(util.Base64DecodeString("SGFsbA=", nil)), "Hall") check(string(util.Base64DecodeInPlace([]byte("SGFsbA="))), "Hall") check(string(util.Base64DecodeString("SGFsbG8===", nil)), "Hallo") check(string(util.Base64DecodeInPlace([]byte("SGFsbG8==="))), "Hallo") check(string(util.Base64DecodeString("SGFsbA", nil)), "Hall") check(string(util.Base64DecodeInPlace([]byte("SGFsbA"))), "Hall") check(string(util.Base64DecodeString("SGFsbG8=", &devnull)), "Hallo") check(devnull, 0) check(string(util.Base64DecodeString("SGFsbA==", &devnull)), "Hall") check(devnull, 0) check(string(util.Base64DecodeString("SGFsbA=", &devnull)), "Hall") check(devnull, 0) check(string(util.Base64DecodeString("SGFsbG8===", &devnull)), "Hallo") check(devnull, 0) check(string(util.Base64DecodeString("AA", nil)), "\000") check(string(util.Base64DecodeInPlace([]byte("AA"))), "\000") check(string(util.Base64DecodeString("AAA", nil)), "\000\000") check(string(util.Base64DecodeInPlace([]byte("AAA"))), "\000\000") var zerocarry int check(string(util.Base64DecodeString("AA", &zerocarry)), "") check(zerocarry != 0, true) check(string(util.Base64DecodeString("=", &zerocarry)), "\000") check(zerocarry, 0) check(string(util.Base64DecodeString("AAA", &zerocarry)), "") check(zerocarry != 0, true) check(string(util.Base64DecodeString("=", &zerocarry)), "\000\000") check(zerocarry, 0) testbuf := make([]byte, 1024) for i := range testbuf { testbuf[i] = byte(i) } error_list := "" for length := 0; length <= 12; length++ { for eq := 0; eq <= 4; eq++ { for err := 0; err <= 12; err++ { b64_1 := base64.StdEncoding.EncodeToString(testbuf[0 : 512-length]) testslice := b64_1[0:] errors := []int{0} for e := 0; e < err; e++ { errors = append(errors, errors[e]+rand.Intn(len(testslice)-errors[e])) } errors = append(errors, len(testslice)) teststr := "" for i := 0; i < len(errors)-1; i++ { if i != 0 { teststr = teststr + "\000\n" } teststr = teststr + testslice[errors[i]:errors[i+1]] } for i := 0; i < eq; i++ { teststr += "=" } // because we're concatenating we need at least 1 "=" if the // first string ends in an incomplete block if eq == 0 && (length&3) != 0 { teststr += "=" } b64_2 := base64.URLEncoding.EncodeToString(testbuf[512-length:]) testslice = b64_2[0:] errors = []int{0} for e := 0; e < err; e++ { errors = append(errors, errors[e]+rand.Intn(len(testslice)-errors[e])) } errors = append(errors, len(testslice)) for i := 0; i < len(errors)-1; i++ { if i != 0 { teststr = teststr + " " } teststr = teststr + testslice[errors[i]:errors[i+1]] } for i := 0; i < eq; i++ { teststr += "=" } for parts := 0; parts < 5; parts++ { stops := []int{0} for e := 0; e < parts; e++ { stops = append(stops, stops[e]+rand.Intn(len(teststr)-stops[e])) } stops = append(stops, len(teststr)) decoded := "" carry := 0 for i := 0; i < len(stops)-1; i++ { decoded += string(util.Base64DecodeString(teststr[stops[i]:stops[i+1]], &carry)) } if decoded != string(testbuf) { error_list += fmt.Sprintf("(util.Base64DecodeString() failed for length=%v eq=%v err=%v parts=%v)\n", length, eq, err, parts) } buffy := []byte(string(teststr)) decbuffy := util.Base64DecodeInPlace(buffy) if &(decbuffy[0]) != &(buffy[0]) || // verify the in-place property string(decbuffy) != string(testbuf) { error_list += fmt.Sprintf("(util.Base64DecodeInPlace() failed for length=%v eq=%v err=%v parts=%v)\n", length, eq, err, parts) } } } } } check(error_list, "") buffy := make([]byte, 1024) st := "Nehmt, esst. Dies ist mein Leib - sprach der Schokohase" copy(buffy[32:], st) result := util.Base64EncodeInPlace(buffy[:32+len(st)], 32) check(&(buffy[0]) == &(result[0]), true) check(cap(result), cap(buffy)) check(string(result), "TmVobXQsIGVzc3QuIERpZXMgaXN0IG1laW4gTGVpYiAtIHNwcmFjaCBkZXIgU2Nob2tvaGFzZQ==") st = "Nehmt, esst. Dies ist mein Leib - sprach der Schokohase\n" copy(buffy[256:], st) result = util.Base64EncodeInPlace(buffy[:256+len(st)], 256) check(&(buffy[0]) == &(result[0]), true) check(cap(result), cap(buffy)) check(string(result), "TmVobXQsIGVzc3QuIERpZXMgaXN0IG1laW4gTGVpYiAtIHNwcmFjaCBkZXIgU2Nob2tvaGFzZQo=") for n := 0; n <= 12; n++ { buffy = make([]byte, n) for i := range buffy { buffy[i] = byte(i) } check(string(util.Base64EncodeString(string(buffy))), base64.StdEncoding.EncodeToString(buffy)) } }