diff --git a/keygen.go b/keygen.go
index 628f2d75..5520894d 100644
--- a/keygen.go
+++ b/keygen.go
@@ -4,9 +4,6 @@ import (
 	"os"
         "io"
 	"big"
-	"fmt"
-        "strings"
-        "bufio"
 	"strconv"
 	"crypto/rsa"
         "crypto/ecdsa"
@@ -34,8 +31,12 @@ func (r *RR_DNSKEY) Generate(bits int) (PrivateKey, os.Error) {
 		if bits < 1024 || bits > 4096 {
 			return nil, ErrKeySize
 		}
-        case ECDSAP256SHA256, ECDSAP384SHA384:
-                if bits != 0 {
+        case ECDSAP256SHA256:
+                if bits != 256 {
+                        return nil, ErrKeySize
+                }
+        case ECDSAP384SHA384:
+                if bits != 384 {
                         return nil, ErrKeySize
                 }
 	}
@@ -112,68 +113,50 @@ func (r *RR_DNSKEY) PrivateKeyString(p PrivateKey) (s string) {
 }
 
 func (k *RR_DNSKEY) ReadPrivateKey(q io.Reader) (PrivateKey, os.Error) {
-        r := bufio.NewReader(q)
-	line, _, err := r.ReadLine()
-private:
-	for err == nil {
-                str := strings.Split(string(line), ": ", 2)
-                switch str[0] {
-                case "Private-key-format":
-                        if str[1] != "v1.2" && str[1] != "v1.3" {
-                                return nil, ErrPrivKey
-                        }
-                case "Algorithm":
-                        // 5 (RSASHA1) for instance
-                        a := strings.Split(str[1], " ", 2)
-                        alg, _ := strconv.Atoi(a[0])
-                        if alg == 0 {
-                                return nil, ErrAlg
-                        }
-                        k.Algorithm = uint8(alg)
-                        break private
-                }
-		line, _, err = r.ReadLine()
+        kv, _ := Kparse(q)
+        if _, ok := kv["private-key-format"]; !ok {
+                return nil, ErrPrivKey
         }
-        switch k.Algorithm {
-        case RSAMD5, RSASHA1, RSASHA256, RSASHA512:
-                return k.readPrivateKeyRSA(r)
-        case ECDSAP256SHA256, ECDSAP384SHA384:
-                return k.readPrivateKeyECDSA(r)
+        if kv["private-key-format"] != "v1.2" || kv["private-key-format"] != "v1.3" {
+                return nil, ErrPrivKey
+        }
+        switch kv["algorithm"] {
+        case "RSAMD5", "RSASHA1", "RSASHA256", "RSASHA512":
+                return k.readPrivateKeyRSA(kv)
+        case "ECDSAP256SHA256", "ECDSAP384SHA384":
+                return k.readPrivateKeyECDSA(kv)
         }
 	return nil, ErrKey
 }
 
 // Read a private key (file) string and create a public key. Return the private key.
-func (k *RR_DNSKEY) readPrivateKeyRSA(r *bufio.Reader) (PrivateKey, os.Error) {
+func (k *RR_DNSKEY) readPrivateKeyRSA(kv map[string]string) (PrivateKey, os.Error) {
 	p := new(rsa.PrivateKey)
 	p.Primes = []*big.Int{nil,nil}
-	line, _, err := r.ReadLine()
-	for err == nil {
-                str := strings.Split(string(line), ": ", 2)
-                switch str[0] {
+        for k, v := range kv {
+                switch k {
                 case "Modulus", "PublicExponent", "PrivateExponent", "Prime1", "Prime2":
-                        v, err := packBase64([]byte(str[1]))
+                        v1, err := packBase64([]byte(v))
                         if err != nil {
                                 return nil, err
                         }
-                        switch str[0] {
+                        switch k {
                         case "Modulus":
                                 p.PublicKey.N = big.NewInt(0)
-                                p.PublicKey.N.SetBytes(v)
+                                p.PublicKey.N.SetBytes(v1)
                         case "PublicExponent":
                                 i := big.NewInt(0)
-                                i.SetBytes(v)
-                                // Int64 should be large enough
-                                p.PublicKey.E = int(i.Int64())
+                                i.SetBytes(v1)
+                                p.PublicKey.E = int(i.Int64()) // int64 should be large enough
                         case "PrivateExponent":
                                 p.D = big.NewInt(0)
-                                p.D.SetBytes(v)
+                                p.D.SetBytes(v1)
                         case "Prime1":
                                 p.Primes[0] = big.NewInt(0)
-                                p.Primes[0].SetBytes(v)
+                                p.Primes[0].SetBytes(v1)
                         case "Prime2":
                                 p.Primes[1] = big.NewInt(0)
-                                p.Primes[1].SetBytes(v)
+                                p.Primes[1].SetBytes(v1)
                         }
                 case "Exponent1", "Exponent2", "Coefficient":
                         // not used in Go (yet)
@@ -182,7 +165,6 @@ func (k *RR_DNSKEY) readPrivateKeyRSA(r *bufio.Reader) (PrivateKey, os.Error) {
                 default:
                         return nil, ErrKey
                 }
-		line, _, err = r.ReadLine()
 	}
 	if ! k.setPublicKeyRSA(p.PublicKey.E, p.PublicKey.N) {
                 return nil, ErrKey
@@ -190,30 +172,23 @@ func (k *RR_DNSKEY) readPrivateKeyRSA(r *bufio.Reader) (PrivateKey, os.Error) {
 	return p, nil
 }
 
-// Read a private key (file) string and create a public key. Return the private key.
-func (k *RR_DNSKEY) readPrivateKeyECDSA(r *bufio.Reader) (PrivateKey, os.Error) {
+func (k *RR_DNSKEY) readPrivateKeyECDSA(kv map[string]string) (PrivateKey, os.Error) {
 	p := new(ecdsa.PrivateKey)
 	p.D = big.NewInt(0)
-	var left, right string
-	line, _, err := r.ReadLine()
-	for err == nil {
-		n, _ := fmt.Sscanf(string(line), "%s %s+\n", &left, &right)
-		if n > 0 {
-			switch left {
-			case "PrivateKey:":
-				v, err := packBase64([]byte(right))
-				if err != nil {
-					return nil, err
-				}
-                                p.D.SetBytes(v)
-			case "Created:", "Publish:", "Activate:":
-				/* not used in Go (yet) */
-			default:
-				return nil, ErrKey
-			}
-		}
-		line, _, err = r.ReadLine()
-	}
+        for k, v := range kv {
+                switch k {
+                case "PrivateKey:":
+                        v1, err := packBase64([]byte(v))
+                        if err != nil {
+                                return nil, err
+                        }
+                        p.D.SetBytes(v1)
+                case "Created:", "Publish:", "Activate:":
+                        /* not used in Go (yet) */
+                default:
+                        return nil, ErrKey
+                }
+        }
 	//if ! k.setPublicKeyRSA(p.PublicKey.E, p.PublicKey.N) {
         //        return nil, ErrKey
         //}
diff --git a/kparse.go b/kparse.go
index 7441936b..590d5d72 100644
--- a/kparse.go
+++ b/kparse.go
@@ -13,11 +13,11 @@ import (
 
 
 // line 16 "kparse.go"
-var k_start int = 84
-var k_first_final int = 84
+var k_start int = 109
+var k_first_final int = 109
 var k_error int = 0
 
-var k_en_main int = 84
+var k_en_main int = 109
 
 
 // line 15 "kparse.rl"
@@ -42,35 +42,45 @@ func Kparse(q io.Reader) (m map[string]string, err os.Error) {
 	if p == pe { goto _test_eof }
 	switch cs {
 	case -666: // i am a hack D:
-tr12:
+tr13:
 // line 30 "kparse.rl"
 	{ m[k] = data[mark:p] }
-	goto st84
-st84:
+	goto st109
+tr28:
+// line 31 "kparse.rl"
+	{ m[k] = data[mark:p-1] }
+	goto st109
+tr40:
+// line 30 "kparse.rl"
+	{ m[k] = data[mark:p] }
+// line 31 "kparse.rl"
+	{ m[k] = data[mark:p-1] }
+	goto st109
+st109:
 	p++
-	if p == pe { goto _test_eof84 }
+	if p == pe { goto _test_eof109 }
 	fallthrough
-case 84:
-// line 55 "kparse.go"
+case 109:
+// line 65 "kparse.go"
 	switch data[p] {
-		case 65: goto tr80
-		case 67: goto tr81
-		case 69: goto tr82
-		case 71: goto tr83
-		case 77: goto tr84
-		case 80: goto tr85
-		case 97: goto tr80
-		case 99: goto tr81
-		case 101: goto tr82
-		case 103: goto tr83
-		case 109: goto tr84
-		case 112: goto tr85
+		case 65: goto tr108
+		case 67: goto tr109
+		case 69: goto tr110
+		case 71: goto tr111
+		case 77: goto tr112
+		case 80: goto tr113
+		case 97: goto tr108
+		case 99: goto tr109
+		case 101: goto tr110
+		case 103: goto tr111
+		case 109: goto tr112
+		case 112: goto tr113
 	}
 	goto st0
 st0:
 cs = 0;
 	goto _out;
-tr80:
+tr108:
 // line 28 "kparse.rl"
 	{ mark = p }
 	goto st1
@@ -79,12 +89,12 @@ st1:
 	if p == pe { goto _test_eof1 }
 	fallthrough
 case 1:
-// line 83 "kparse.go"
+// line 93 "kparse.go"
 	switch data[p] {
 		case 67: goto st2
-		case 76: goto st12
+		case 76: goto st37
 		case 99: goto st2
-		case 108: goto st12
+		case 108: goto st37
 	}
 	goto st0
 st2:
@@ -163,7 +173,7 @@ st9:
 	if p == pe { goto _test_eof9 }
 	fallthrough
 case 9:
-// line 167 "kparse.go"
+// line 177 "kparse.go"
 	if data[p] == 32 { goto st10 }
 	goto st0
 st10:
@@ -177,8 +187,12 @@ case 10:
 		case 61: goto tr11
 		case 92: goto tr11
 	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto tr11 }
+	if data[p] < 48 {
+		if data[p] > 41 {
+			if 46 <= data[p] && data[p] <= 47 { goto tr11 }
+		} else if data[p] >= 40 {
+			goto tr11
+		}
 	} else if data[p] > 57 {
 		if data[p] > 90 {
 			if 97 <= data[p] && data[p] <= 122 { goto tr11 }
@@ -186,7 +200,7 @@ case 10:
 			goto tr11
 		}
 	} else {
-		goto tr11
+		goto tr12
 	}
 	goto st0
 tr11:
@@ -198,9 +212,9 @@ st11:
 	if p == pe { goto _test_eof11 }
 	fallthrough
 case 11:
-// line 202 "kparse.go"
+// line 216 "kparse.go"
 	switch data[p] {
-		case 10: goto tr12
+		case 10: goto tr13
 		case 32: goto st11
 		case 43: goto st11
 		case 61: goto st11
@@ -218,14 +232,38 @@ case 11:
 		goto st11
 	}
 	goto st0
+tr12:
+// line 28 "kparse.rl"
+	{ mark = p }
+	goto st12
 st12:
 	p++
 	if p == pe { goto _test_eof12 }
 	fallthrough
 case 12:
+// line 245 "kparse.go"
 	switch data[p] {
-		case 71: goto st13
-		case 103: goto st13
+		case 9: goto st13
+		case 10: goto tr13
+		case 32: goto st25
+		case 43: goto st11
+		case 61: goto st11
+		case 92: goto st11
+	}
+	if data[p] < 48 {
+		if data[p] > 41 {
+			if 46 <= data[p] && data[p] <= 47 { goto st11 }
+		} else if data[p] >= 40 {
+			goto st11
+		}
+	} else if data[p] > 57 {
+		if data[p] > 90 {
+			if 97 <= data[p] && data[p] <= 122 { goto st11 }
+		} else if data[p] >= 65 {
+			goto st11
+		}
+	} else {
+		goto st12
 	}
 	goto st0
 st13:
@@ -234,8 +272,9 @@ st13:
 	fallthrough
 case 13:
 	switch data[p] {
-		case 79: goto st14
-		case 111: goto st14
+		case 9: goto st13
+		case 32: goto st13
+		case 40: goto st14
 	}
 	goto st0
 st14:
@@ -244,18 +283,23 @@ st14:
 	fallthrough
 case 14:
 	switch data[p] {
-		case 82: goto st15
-		case 114: goto st15
+		case 82: goto tr19
+		case 114: goto tr19
 	}
 	goto st0
+tr19:
+// line 28 "kparse.rl"
+	{ mark = p }
+	goto st15
 st15:
 	p++
 	if p == pe { goto _test_eof15 }
 	fallthrough
 case 15:
+// line 300 "kparse.go"
 	switch data[p] {
-		case 73: goto st16
-		case 105: goto st16
+		case 83: goto st16
+		case 115: goto st16
 	}
 	goto st0
 st16:
@@ -264,8 +308,8 @@ st16:
 	fallthrough
 case 16:
 	switch data[p] {
-		case 84: goto st17
-		case 116: goto st17
+		case 65: goto st17
+		case 97: goto st17
 	}
 	goto st0
 st17:
@@ -274,8 +318,8 @@ st17:
 	fallthrough
 case 17:
 	switch data[p] {
-		case 72: goto st18
-		case 104: goto st18
+		case 83: goto st18
+		case 115: goto st18
 	}
 	goto st0
 st18:
@@ -284,25 +328,18 @@ st18:
 	fallthrough
 case 18:
 	switch data[p] {
-		case 77: goto st8
-		case 109: goto st8
+		case 72: goto st19
+		case 104: goto st19
 	}
 	goto st0
-tr81:
-// line 28 "kparse.rl"
-	{ mark = p }
-	goto st19
 st19:
 	p++
 	if p == pe { goto _test_eof19 }
 	fallthrough
 case 19:
-// line 301 "kparse.go"
 	switch data[p] {
-		case 79: goto st20
-		case 82: goto st29
-		case 111: goto st20
-		case 114: goto st29
+		case 65: goto st20
+		case 97: goto st20
 	}
 	goto st0
 st20:
@@ -311,8 +348,8 @@ st20:
 	fallthrough
 case 20:
 	switch data[p] {
-		case 69: goto st21
-		case 101: goto st21
+		case 49: goto st21
+		case 50: goto st23
 	}
 	goto st0
 st21:
@@ -320,40 +357,28 @@ st21:
 	if p == pe { goto _test_eof21 }
 	fallthrough
 case 21:
-	switch data[p] {
-		case 70: goto st22
-		case 102: goto st22
-	}
+	if data[p] == 41 { goto st22 }
 	goto st0
 st22:
 	p++
 	if p == pe { goto _test_eof22 }
 	fallthrough
 case 22:
-	switch data[p] {
-		case 70: goto st23
-		case 102: goto st23
-	}
+	if data[p] == 10 { goto tr28 }
 	goto st0
 st23:
 	p++
 	if p == pe { goto _test_eof23 }
 	fallthrough
 case 23:
-	switch data[p] {
-		case 73: goto st24
-		case 105: goto st24
-	}
+	if data[p] == 53 { goto st24 }
 	goto st0
 st24:
 	p++
 	if p == pe { goto _test_eof24 }
 	fallthrough
 case 24:
-	switch data[p] {
-		case 67: goto st25
-		case 99: goto st25
-	}
+	if data[p] == 54 { goto st21 }
 	goto st0
 st25:
 	p++
@@ -361,8 +386,21 @@ st25:
 	fallthrough
 case 25:
 	switch data[p] {
-		case 73: goto st26
-		case 105: goto st26
+		case 9: goto st13
+		case 10: goto tr13
+		case 32: goto st25
+		case 40: goto st26
+		case 41: goto st11
+		case 43: goto st11
+		case 61: goto st11
+		case 92: goto st11
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto st11 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto st11 }
+	} else {
+		goto st11
 	}
 	goto st0
 st26:
@@ -371,18 +409,55 @@ st26:
 	fallthrough
 case 26:
 	switch data[p] {
-		case 69: goto st27
-		case 101: goto st27
+		case 10: goto tr13
+		case 32: goto st11
+		case 43: goto st11
+		case 61: goto st11
+		case 82: goto tr31
+		case 92: goto st11
+		case 114: goto tr31
+	}
+	if data[p] < 46 {
+		if 40 <= data[p] && data[p] <= 41 { goto st11 }
+	} else if data[p] > 57 {
+		if data[p] > 90 {
+			if 97 <= data[p] && data[p] <= 122 { goto st11 }
+		} else if data[p] >= 65 {
+			goto st11
+		}
+	} else {
+		goto st11
 	}
 	goto st0
+tr31:
+// line 28 "kparse.rl"
+	{ mark = p }
+	goto st27
 st27:
 	p++
 	if p == pe { goto _test_eof27 }
 	fallthrough
 case 27:
+// line 442 "kparse.go"
 	switch data[p] {
-		case 78: goto st28
-		case 110: goto st28
+		case 10: goto tr13
+		case 32: goto st11
+		case 43: goto st11
+		case 61: goto st11
+		case 83: goto st28
+		case 92: goto st11
+		case 115: goto st28
+	}
+	if data[p] < 46 {
+		if 40 <= data[p] && data[p] <= 41 { goto st11 }
+	} else if data[p] > 57 {
+		if data[p] > 90 {
+			if 97 <= data[p] && data[p] <= 122 { goto st11 }
+		} else if data[p] >= 65 {
+			goto st11
+		}
+	} else {
+		goto st11
 	}
 	goto st0
 st28:
@@ -391,8 +466,24 @@ st28:
 	fallthrough
 case 28:
 	switch data[p] {
-		case 84: goto st8
-		case 116: goto st8
+		case 10: goto tr13
+		case 32: goto st11
+		case 43: goto st11
+		case 61: goto st11
+		case 65: goto st29
+		case 92: goto st11
+		case 97: goto st29
+	}
+	if data[p] < 46 {
+		if 40 <= data[p] && data[p] <= 41 { goto st11 }
+	} else if data[p] > 57 {
+		if data[p] > 90 {
+			if 98 <= data[p] && data[p] <= 122 { goto st11 }
+		} else if data[p] >= 66 {
+			goto st11
+		}
+	} else {
+		goto st11
 	}
 	goto st0
 st29:
@@ -401,8 +492,24 @@ st29:
 	fallthrough
 case 29:
 	switch data[p] {
-		case 69: goto st30
-		case 101: goto st30
+		case 10: goto tr13
+		case 32: goto st11
+		case 43: goto st11
+		case 61: goto st11
+		case 83: goto st30
+		case 92: goto st11
+		case 115: goto st30
+	}
+	if data[p] < 46 {
+		if 40 <= data[p] && data[p] <= 41 { goto st11 }
+	} else if data[p] > 57 {
+		if data[p] > 90 {
+			if 97 <= data[p] && data[p] <= 122 { goto st11 }
+		} else if data[p] >= 65 {
+			goto st11
+		}
+	} else {
+		goto st11
 	}
 	goto st0
 st30:
@@ -411,8 +518,24 @@ st30:
 	fallthrough
 case 30:
 	switch data[p] {
-		case 65: goto st31
-		case 97: goto st31
+		case 10: goto tr13
+		case 32: goto st11
+		case 43: goto st11
+		case 61: goto st11
+		case 72: goto st31
+		case 92: goto st11
+		case 104: goto st31
+	}
+	if data[p] < 46 {
+		if 40 <= data[p] && data[p] <= 41 { goto st11 }
+	} else if data[p] > 57 {
+		if data[p] > 90 {
+			if 97 <= data[p] && data[p] <= 122 { goto st11 }
+		} else if data[p] >= 65 {
+			goto st11
+		}
+	} else {
+		goto st11
 	}
 	goto st0
 st31:
@@ -421,8 +544,24 @@ st31:
 	fallthrough
 case 31:
 	switch data[p] {
-		case 84: goto st32
-		case 116: goto st32
+		case 10: goto tr13
+		case 32: goto st11
+		case 43: goto st11
+		case 61: goto st11
+		case 65: goto st32
+		case 92: goto st11
+		case 97: goto st32
+	}
+	if data[p] < 46 {
+		if 40 <= data[p] && data[p] <= 41 { goto st11 }
+	} else if data[p] > 57 {
+		if data[p] > 90 {
+			if 98 <= data[p] && data[p] <= 122 { goto st11 }
+		} else if data[p] >= 66 {
+			goto st11
+		}
+	} else {
+		goto st11
 	}
 	goto st0
 st32:
@@ -431,8 +570,24 @@ st32:
 	fallthrough
 case 32:
 	switch data[p] {
-		case 69: goto st33
-		case 101: goto st33
+		case 10: goto tr13
+		case 32: goto st11
+		case 43: goto st11
+		case 49: goto st33
+		case 50: goto st35
+		case 61: goto st11
+		case 92: goto st11
+	}
+	if data[p] < 46 {
+		if 40 <= data[p] && data[p] <= 41 { goto st11 }
+	} else if data[p] > 57 {
+		if data[p] > 90 {
+			if 97 <= data[p] && data[p] <= 122 { goto st11 }
+		} else if data[p] >= 65 {
+			goto st11
+		}
+	} else {
+		goto st11
 	}
 	goto st0
 st33:
@@ -441,23 +596,44 @@ st33:
 	fallthrough
 case 33:
 	switch data[p] {
-		case 68: goto st8
-		case 100: goto st8
+		case 10: goto tr13
+		case 32: goto st11
+		case 40: goto st11
+		case 41: goto st34
+		case 43: goto st11
+		case 61: goto st11
+		case 92: goto st11
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto st11 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto st11 }
+	} else {
+		goto st11
 	}
 	goto st0
-tr82:
-// line 28 "kparse.rl"
-	{ mark = p }
-	goto st34
 st34:
 	p++
 	if p == pe { goto _test_eof34 }
 	fallthrough
 case 34:
-// line 458 "kparse.go"
 	switch data[p] {
-		case 88: goto st35
-		case 120: goto st35
+		case 10: goto tr40
+		case 32: goto st11
+		case 43: goto st11
+		case 61: goto st11
+		case 92: goto st11
+	}
+	if data[p] < 46 {
+		if 40 <= data[p] && data[p] <= 41 { goto st11 }
+	} else if data[p] > 57 {
+		if data[p] > 90 {
+			if 97 <= data[p] && data[p] <= 122 { goto st11 }
+		} else if data[p] >= 65 {
+			goto st11
+		}
+	} else {
+		goto st11
 	}
 	goto st0
 st35:
@@ -466,8 +642,23 @@ st35:
 	fallthrough
 case 35:
 	switch data[p] {
-		case 80: goto st36
-		case 112: goto st36
+		case 10: goto tr13
+		case 32: goto st11
+		case 43: goto st11
+		case 53: goto st36
+		case 61: goto st11
+		case 92: goto st11
+	}
+	if data[p] < 46 {
+		if 40 <= data[p] && data[p] <= 41 { goto st11 }
+	} else if data[p] > 57 {
+		if data[p] > 90 {
+			if 97 <= data[p] && data[p] <= 122 { goto st11 }
+		} else if data[p] >= 65 {
+			goto st11
+		}
+	} else {
+		goto st11
 	}
 	goto st0
 st36:
@@ -476,8 +667,23 @@ st36:
 	fallthrough
 case 36:
 	switch data[p] {
-		case 79: goto st37
-		case 111: goto st37
+		case 10: goto tr13
+		case 32: goto st11
+		case 43: goto st11
+		case 54: goto st33
+		case 61: goto st11
+		case 92: goto st11
+	}
+	if data[p] < 46 {
+		if 40 <= data[p] && data[p] <= 41 { goto st11 }
+	} else if data[p] > 57 {
+		if data[p] > 90 {
+			if 97 <= data[p] && data[p] <= 122 { goto st11 }
+		} else if data[p] >= 65 {
+			goto st11
+		}
+	} else {
+		goto st11
 	}
 	goto st0
 st37:
@@ -486,8 +692,8 @@ st37:
 	fallthrough
 case 37:
 	switch data[p] {
-		case 78: goto st38
-		case 110: goto st38
+		case 71: goto st38
+		case 103: goto st38
 	}
 	goto st0
 st38:
@@ -496,8 +702,8 @@ st38:
 	fallthrough
 case 38:
 	switch data[p] {
-		case 69: goto st39
-		case 101: goto st39
+		case 79: goto st39
+		case 111: goto st39
 	}
 	goto st0
 st39:
@@ -506,8 +712,8 @@ st39:
 	fallthrough
 case 39:
 	switch data[p] {
-		case 78: goto st40
-		case 110: goto st40
+		case 82: goto st40
+		case 114: goto st40
 	}
 	goto st0
 st40:
@@ -516,8 +722,8 @@ st40:
 	fallthrough
 case 40:
 	switch data[p] {
-		case 84: goto st41
-		case 116: goto st41
+		case 73: goto st41
+		case 105: goto st41
 	}
 	goto st0
 st41:
@@ -525,21 +731,19 @@ st41:
 	if p == pe { goto _test_eof41 }
 	fallthrough
 case 41:
-	if 49 <= data[p] && data[p] <= 50 { goto st8 }
+	switch data[p] {
+		case 84: goto st42
+		case 116: goto st42
+	}
 	goto st0
-tr83:
-// line 28 "kparse.rl"
-	{ mark = p }
-	goto st42
 st42:
 	p++
 	if p == pe { goto _test_eof42 }
 	fallthrough
 case 42:
-// line 540 "kparse.go"
 	switch data[p] {
-		case 79: goto st43
-		case 111: goto st43
+		case 72: goto st43
+		case 104: goto st43
 	}
 	goto st0
 st43:
@@ -548,18 +752,25 @@ st43:
 	fallthrough
 case 43:
 	switch data[p] {
-		case 83: goto st44
-		case 115: goto st44
+		case 77: goto st8
+		case 109: goto st8
 	}
 	goto st0
+tr109:
+// line 28 "kparse.rl"
+	{ mark = p }
+	goto st44
 st44:
 	p++
 	if p == pe { goto _test_eof44 }
 	fallthrough
 case 44:
+// line 769 "kparse.go"
 	switch data[p] {
-		case 84: goto st45
-		case 116: goto st45
+		case 79: goto st45
+		case 82: goto st54
+		case 111: goto st45
+		case 114: goto st54
 	}
 	goto st0
 st45:
@@ -568,8 +779,8 @@ st45:
 	fallthrough
 case 45:
 	switch data[p] {
-		case 65: goto st46
-		case 97: goto st46
+		case 69: goto st46
+		case 101: goto st46
 	}
 	goto st0
 st46:
@@ -578,8 +789,8 @@ st46:
 	fallthrough
 case 46:
 	switch data[p] {
-		case 83: goto st47
-		case 115: goto st47
+		case 70: goto st47
+		case 102: goto st47
 	}
 	goto st0
 st47:
@@ -588,8 +799,8 @@ st47:
 	fallthrough
 case 47:
 	switch data[p] {
-		case 78: goto st48
-		case 110: goto st48
+		case 70: goto st48
+		case 102: goto st48
 	}
 	goto st0
 st48:
@@ -597,21 +808,19 @@ st48:
 	if p == pe { goto _test_eof48 }
 	fallthrough
 case 48:
-	if data[p] == 49 { goto st8 }
+	switch data[p] {
+		case 73: goto st49
+		case 105: goto st49
+	}
 	goto st0
-tr84:
-// line 28 "kparse.rl"
-	{ mark = p }
-	goto st49
 st49:
 	p++
 	if p == pe { goto _test_eof49 }
 	fallthrough
 case 49:
-// line 612 "kparse.go"
 	switch data[p] {
-		case 79: goto st50
-		case 111: goto st50
+		case 67: goto st50
+		case 99: goto st50
 	}
 	goto st0
 st50:
@@ -620,8 +829,8 @@ st50:
 	fallthrough
 case 50:
 	switch data[p] {
-		case 68: goto st51
-		case 100: goto st51
+		case 73: goto st51
+		case 105: goto st51
 	}
 	goto st0
 st51:
@@ -630,8 +839,8 @@ st51:
 	fallthrough
 case 51:
 	switch data[p] {
-		case 85: goto st52
-		case 117: goto st52
+		case 69: goto st52
+		case 101: goto st52
 	}
 	goto st0
 st52:
@@ -640,8 +849,8 @@ st52:
 	fallthrough
 case 52:
 	switch data[p] {
-		case 76: goto st53
-		case 108: goto st53
+		case 78: goto st53
+		case 110: goto st53
 	}
 	goto st0
 st53:
@@ -650,8 +859,8 @@ st53:
 	fallthrough
 case 53:
 	switch data[p] {
-		case 85: goto st54
-		case 117: goto st54
+		case 84: goto st8
+		case 116: goto st8
 	}
 	goto st0
 st54:
@@ -660,25 +869,18 @@ st54:
 	fallthrough
 case 54:
 	switch data[p] {
-		case 83: goto st8
-		case 115: goto st8
+		case 69: goto st55
+		case 101: goto st55
 	}
 	goto st0
-tr85:
-// line 28 "kparse.rl"
-	{ mark = p }
-	goto st55
 st55:
 	p++
 	if p == pe { goto _test_eof55 }
 	fallthrough
 case 55:
-// line 677 "kparse.go"
 	switch data[p] {
-		case 82: goto st56
-		case 85: goto st78
-		case 114: goto st56
-		case 117: goto st78
+		case 65: goto st56
+		case 97: goto st56
 	}
 	goto st0
 st56:
@@ -687,8 +889,8 @@ st56:
 	fallthrough
 case 56:
 	switch data[p] {
-		case 73: goto st57
-		case 105: goto st57
+		case 84: goto st57
+		case 116: goto st57
 	}
 	goto st0
 st57:
@@ -697,10 +899,8 @@ st57:
 	fallthrough
 case 57:
 	switch data[p] {
-		case 77: goto st58
-		case 86: goto st59
-		case 109: goto st58
-		case 118: goto st59
+		case 69: goto st58
+		case 101: goto st58
 	}
 	goto st0
 st58:
@@ -709,18 +909,23 @@ st58:
 	fallthrough
 case 58:
 	switch data[p] {
-		case 69: goto st41
-		case 101: goto st41
+		case 68: goto st8
+		case 100: goto st8
 	}
 	goto st0
+tr110:
+// line 28 "kparse.rl"
+	{ mark = p }
+	goto st59
 st59:
 	p++
 	if p == pe { goto _test_eof59 }
 	fallthrough
 case 59:
+// line 926 "kparse.go"
 	switch data[p] {
-		case 65: goto st60
-		case 97: goto st60
+		case 88: goto st60
+		case 120: goto st60
 	}
 	goto st0
 st60:
@@ -729,8 +934,8 @@ st60:
 	fallthrough
 case 60:
 	switch data[p] {
-		case 84: goto st61
-		case 116: goto st61
+		case 80: goto st61
+		case 112: goto st61
 	}
 	goto st0
 st61:
@@ -739,8 +944,8 @@ st61:
 	fallthrough
 case 61:
 	switch data[p] {
-		case 69: goto st62
-		case 101: goto st62
+		case 79: goto st62
+		case 111: goto st62
 	}
 	goto st0
 st62:
@@ -749,11 +954,8 @@ st62:
 	fallthrough
 case 62:
 	switch data[p] {
-		case 45: goto st63
-		case 69: goto st72
-		case 75: goto st76
-		case 101: goto st72
-		case 107: goto st76
+		case 78: goto st63
+		case 110: goto st63
 	}
 	goto st0
 st63:
@@ -762,8 +964,8 @@ st63:
 	fallthrough
 case 63:
 	switch data[p] {
-		case 75: goto st64
-		case 107: goto st64
+		case 69: goto st64
+		case 101: goto st64
 	}
 	goto st0
 st64:
@@ -772,8 +974,8 @@ st64:
 	fallthrough
 case 64:
 	switch data[p] {
-		case 69: goto st65
-		case 101: goto st65
+		case 78: goto st65
+		case 110: goto st65
 	}
 	goto st0
 st65:
@@ -782,8 +984,8 @@ st65:
 	fallthrough
 case 65:
 	switch data[p] {
-		case 89: goto st66
-		case 121: goto st66
+		case 84: goto st66
+		case 116: goto st66
 	}
 	goto st0
 st66:
@@ -791,16 +993,21 @@ st66:
 	if p == pe { goto _test_eof66 }
 	fallthrough
 case 66:
-	if data[p] == 45 { goto st67 }
+	if 49 <= data[p] && data[p] <= 50 { goto st8 }
 	goto st0
+tr111:
+// line 28 "kparse.rl"
+	{ mark = p }
+	goto st67
 st67:
 	p++
 	if p == pe { goto _test_eof67 }
 	fallthrough
 case 67:
+// line 1008 "kparse.go"
 	switch data[p] {
-		case 70: goto st68
-		case 102: goto st68
+		case 79: goto st68
+		case 111: goto st68
 	}
 	goto st0
 st68:
@@ -809,8 +1016,8 @@ st68:
 	fallthrough
 case 68:
 	switch data[p] {
-		case 79: goto st69
-		case 111: goto st69
+		case 83: goto st69
+		case 115: goto st69
 	}
 	goto st0
 st69:
@@ -819,8 +1026,8 @@ st69:
 	fallthrough
 case 69:
 	switch data[p] {
-		case 82: goto st70
-		case 114: goto st70
+		case 84: goto st70
+		case 116: goto st70
 	}
 	goto st0
 st70:
@@ -829,8 +1036,8 @@ st70:
 	fallthrough
 case 70:
 	switch data[p] {
-		case 77: goto st71
-		case 109: goto st71
+		case 65: goto st71
+		case 97: goto st71
 	}
 	goto st0
 st71:
@@ -839,8 +1046,8 @@ st71:
 	fallthrough
 case 71:
 	switch data[p] {
-		case 65: goto st28
-		case 97: goto st28
+		case 83: goto st72
+		case 115: goto st72
 	}
 	goto st0
 st72:
@@ -849,8 +1056,8 @@ st72:
 	fallthrough
 case 72:
 	switch data[p] {
-		case 88: goto st73
-		case 120: goto st73
+		case 78: goto st73
+		case 110: goto st73
 	}
 	goto st0
 st73:
@@ -858,16 +1065,18 @@ st73:
 	if p == pe { goto _test_eof73 }
 	fallthrough
 case 73:
-	switch data[p] {
-		case 80: goto st74
-		case 112: goto st74
-	}
+	if data[p] == 49 { goto st8 }
 	goto st0
+tr112:
+// line 28 "kparse.rl"
+	{ mark = p }
+	goto st74
 st74:
 	p++
 	if p == pe { goto _test_eof74 }
 	fallthrough
 case 74:
+// line 1080 "kparse.go"
 	switch data[p] {
 		case 79: goto st75
 		case 111: goto st75
@@ -879,8 +1088,8 @@ st75:
 	fallthrough
 case 75:
 	switch data[p] {
-		case 78: goto st26
-		case 110: goto st26
+		case 68: goto st76
+		case 100: goto st76
 	}
 	goto st0
 st76:
@@ -889,8 +1098,8 @@ st76:
 	fallthrough
 case 76:
 	switch data[p] {
-		case 69: goto st77
-		case 101: goto st77
+		case 85: goto st77
+		case 117: goto st77
 	}
 	goto st0
 st77:
@@ -899,8 +1108,8 @@ st77:
 	fallthrough
 case 77:
 	switch data[p] {
-		case 89: goto st8
-		case 121: goto st8
+		case 76: goto st78
+		case 108: goto st78
 	}
 	goto st0
 st78:
@@ -909,8 +1118,8 @@ st78:
 	fallthrough
 case 78:
 	switch data[p] {
-		case 66: goto st79
-		case 98: goto st79
+		case 85: goto st79
+		case 117: goto st79
 	}
 	goto st0
 st79:
@@ -919,18 +1128,25 @@ st79:
 	fallthrough
 case 79:
 	switch data[p] {
-		case 76: goto st80
-		case 108: goto st80
+		case 83: goto st8
+		case 115: goto st8
 	}
 	goto st0
+tr113:
+// line 28 "kparse.rl"
+	{ mark = p }
+	goto st80
 st80:
 	p++
 	if p == pe { goto _test_eof80 }
 	fallthrough
 case 80:
+// line 1145 "kparse.go"
 	switch data[p] {
-		case 73: goto st81
-		case 105: goto st81
+		case 82: goto st81
+		case 85: goto st103
+		case 114: goto st81
+		case 117: goto st103
 	}
 	goto st0
 st81:
@@ -939,10 +1155,8 @@ st81:
 	fallthrough
 case 81:
 	switch data[p] {
-		case 67: goto st82
-		case 83: goto st83
-		case 99: goto st82
-		case 115: goto st83
+		case 73: goto st82
+		case 105: goto st82
 	}
 	goto st0
 st82:
@@ -951,8 +1165,10 @@ st82:
 	fallthrough
 case 82:
 	switch data[p] {
-		case 69: goto st72
-		case 101: goto st72
+		case 77: goto st83
+		case 86: goto st84
+		case 109: goto st83
+		case 118: goto st84
 	}
 	goto st0
 st83:
@@ -960,13 +1176,265 @@ st83:
 	if p == pe { goto _test_eof83 }
 	fallthrough
 case 83:
+	switch data[p] {
+		case 69: goto st66
+		case 101: goto st66
+	}
+	goto st0
+st84:
+	p++
+	if p == pe { goto _test_eof84 }
+	fallthrough
+case 84:
+	switch data[p] {
+		case 65: goto st85
+		case 97: goto st85
+	}
+	goto st0
+st85:
+	p++
+	if p == pe { goto _test_eof85 }
+	fallthrough
+case 85:
+	switch data[p] {
+		case 84: goto st86
+		case 116: goto st86
+	}
+	goto st0
+st86:
+	p++
+	if p == pe { goto _test_eof86 }
+	fallthrough
+case 86:
+	switch data[p] {
+		case 69: goto st87
+		case 101: goto st87
+	}
+	goto st0
+st87:
+	p++
+	if p == pe { goto _test_eof87 }
+	fallthrough
+case 87:
+	switch data[p] {
+		case 45: goto st88
+		case 69: goto st97
+		case 75: goto st101
+		case 101: goto st97
+		case 107: goto st101
+	}
+	goto st0
+st88:
+	p++
+	if p == pe { goto _test_eof88 }
+	fallthrough
+case 88:
+	switch data[p] {
+		case 75: goto st89
+		case 107: goto st89
+	}
+	goto st0
+st89:
+	p++
+	if p == pe { goto _test_eof89 }
+	fallthrough
+case 89:
+	switch data[p] {
+		case 69: goto st90
+		case 101: goto st90
+	}
+	goto st0
+st90:
+	p++
+	if p == pe { goto _test_eof90 }
+	fallthrough
+case 90:
+	switch data[p] {
+		case 89: goto st91
+		case 121: goto st91
+	}
+	goto st0
+st91:
+	p++
+	if p == pe { goto _test_eof91 }
+	fallthrough
+case 91:
+	if data[p] == 45 { goto st92 }
+	goto st0
+st92:
+	p++
+	if p == pe { goto _test_eof92 }
+	fallthrough
+case 92:
+	switch data[p] {
+		case 70: goto st93
+		case 102: goto st93
+	}
+	goto st0
+st93:
+	p++
+	if p == pe { goto _test_eof93 }
+	fallthrough
+case 93:
+	switch data[p] {
+		case 79: goto st94
+		case 111: goto st94
+	}
+	goto st0
+st94:
+	p++
+	if p == pe { goto _test_eof94 }
+	fallthrough
+case 94:
+	switch data[p] {
+		case 82: goto st95
+		case 114: goto st95
+	}
+	goto st0
+st95:
+	p++
+	if p == pe { goto _test_eof95 }
+	fallthrough
+case 95:
+	switch data[p] {
+		case 77: goto st96
+		case 109: goto st96
+	}
+	goto st0
+st96:
+	p++
+	if p == pe { goto _test_eof96 }
+	fallthrough
+case 96:
+	switch data[p] {
+		case 65: goto st53
+		case 97: goto st53
+	}
+	goto st0
+st97:
+	p++
+	if p == pe { goto _test_eof97 }
+	fallthrough
+case 97:
+	switch data[p] {
+		case 88: goto st98
+		case 120: goto st98
+	}
+	goto st0
+st98:
+	p++
+	if p == pe { goto _test_eof98 }
+	fallthrough
+case 98:
+	switch data[p] {
+		case 80: goto st99
+		case 112: goto st99
+	}
+	goto st0
+st99:
+	p++
+	if p == pe { goto _test_eof99 }
+	fallthrough
+case 99:
+	switch data[p] {
+		case 79: goto st100
+		case 111: goto st100
+	}
+	goto st0
+st100:
+	p++
+	if p == pe { goto _test_eof100 }
+	fallthrough
+case 100:
+	switch data[p] {
+		case 78: goto st51
+		case 110: goto st51
+	}
+	goto st0
+st101:
+	p++
+	if p == pe { goto _test_eof101 }
+	fallthrough
+case 101:
+	switch data[p] {
+		case 69: goto st102
+		case 101: goto st102
+	}
+	goto st0
+st102:
+	p++
+	if p == pe { goto _test_eof102 }
+	fallthrough
+case 102:
+	switch data[p] {
+		case 89: goto st8
+		case 121: goto st8
+	}
+	goto st0
+st103:
+	p++
+	if p == pe { goto _test_eof103 }
+	fallthrough
+case 103:
+	switch data[p] {
+		case 66: goto st104
+		case 98: goto st104
+	}
+	goto st0
+st104:
+	p++
+	if p == pe { goto _test_eof104 }
+	fallthrough
+case 104:
+	switch data[p] {
+		case 76: goto st105
+		case 108: goto st105
+	}
+	goto st0
+st105:
+	p++
+	if p == pe { goto _test_eof105 }
+	fallthrough
+case 105:
+	switch data[p] {
+		case 73: goto st106
+		case 105: goto st106
+	}
+	goto st0
+st106:
+	p++
+	if p == pe { goto _test_eof106 }
+	fallthrough
+case 106:
+	switch data[p] {
+		case 67: goto st107
+		case 83: goto st108
+		case 99: goto st107
+		case 115: goto st108
+	}
+	goto st0
+st107:
+	p++
+	if p == pe { goto _test_eof107 }
+	fallthrough
+case 107:
+	switch data[p] {
+		case 69: goto st97
+		case 101: goto st97
+	}
+	goto st0
+st108:
+	p++
+	if p == pe { goto _test_eof108 }
+	fallthrough
+case 108:
 	switch data[p] {
 		case 72: goto st8
 		case 104: goto st8
 	}
 	goto st0
 	}
-	_test_eof84: cs = 84; goto _test_eof; 
+	_test_eof109: cs = 109; goto _test_eof; 
 	_test_eof1: cs = 1; goto _test_eof; 
 	_test_eof2: cs = 2; goto _test_eof; 
 	_test_eof3: cs = 3; goto _test_eof; 
@@ -1050,12 +1518,37 @@ case 83:
 	_test_eof81: cs = 81; goto _test_eof; 
 	_test_eof82: cs = 82; goto _test_eof; 
 	_test_eof83: cs = 83; goto _test_eof; 
+	_test_eof84: cs = 84; goto _test_eof; 
+	_test_eof85: cs = 85; goto _test_eof; 
+	_test_eof86: cs = 86; goto _test_eof; 
+	_test_eof87: cs = 87; goto _test_eof; 
+	_test_eof88: cs = 88; goto _test_eof; 
+	_test_eof89: cs = 89; goto _test_eof; 
+	_test_eof90: cs = 90; goto _test_eof; 
+	_test_eof91: cs = 91; goto _test_eof; 
+	_test_eof92: cs = 92; goto _test_eof; 
+	_test_eof93: cs = 93; goto _test_eof; 
+	_test_eof94: cs = 94; goto _test_eof; 
+	_test_eof95: cs = 95; goto _test_eof; 
+	_test_eof96: cs = 96; goto _test_eof; 
+	_test_eof97: cs = 97; goto _test_eof; 
+	_test_eof98: cs = 98; goto _test_eof; 
+	_test_eof99: cs = 99; goto _test_eof; 
+	_test_eof100: cs = 100; goto _test_eof; 
+	_test_eof101: cs = 101; goto _test_eof; 
+	_test_eof102: cs = 102; goto _test_eof; 
+	_test_eof103: cs = 103; goto _test_eof; 
+	_test_eof104: cs = 104; goto _test_eof; 
+	_test_eof105: cs = 105; goto _test_eof; 
+	_test_eof106: cs = 106; goto _test_eof; 
+	_test_eof107: cs = 107; goto _test_eof; 
+	_test_eof108: cs = 108; goto _test_eof; 
 
 	_test_eof: {}
 	_out: {}
 	}
 
-// line 59 "kparse.rl"
+// line 62 "kparse.rl"
 
             data, err = r.ReadString('\n')
         }
diff --git a/kparse.rl b/kparse.rl
index 2680804b..bbd677e3 100644
--- a/kparse.rl
+++ b/kparse.rl
@@ -28,8 +28,11 @@ func Kparse(q io.Reader) (m map[string]string, err os.Error) {
                 action mark      { mark = p }
                 action setKey    { k = strings.ToLower(data[mark:p]) }
                 action setValue  { m[k] = data[mark:p] }
+                action setAlg    { m[k] = data[mark:p-1] }
 
-                base64 = [a-zA-Z0-9.\\/+=() ]+ >mark;
+                bl = [ \t]+;
+                base64any = [a-zA-Z0-9.\\/+=() ]+ >mark;
+                algorithm = ( 'RSASHA1'i | 'RSASHA256'i ) >mark;
 
                 key = (
                       ('Private-key-format'i)
@@ -49,7 +52,7 @@ func Kparse(q io.Reader) (m map[string]string, err os.Error) {
                     | ('Activate'i)
                 ) >mark %setKey;
                 
-                value = base64 %setValue;
+                value = ( base64any %setValue | digit+ bl '(' algorithm ')' %setAlg );
 
                 line = key ': ' value;
                 main := ( line '\n' )*;