Merge pull request #14 from ffuf/unicode

Unicode encoder and decoder

pkg/pencode/encoders.go

@@ -6,13 +6,15 @@ import (
 )
 
 var availableEncoders = map[string]Encoder{
- "b64encode": Base64Encoder{},
- "b64decode": Base64Decoder{},
- "hexencode": HexEncoder{},
- "hexdecode": HexDecoder{},
- "urlencode": URLEncoder{},
- "urldecode": URLDecoder{},
- "urlencodeall": URLEncoderAll{},
+ "b64encode": Base64Encoder{},
+ "b64decode": Base64Decoder{},
+ "hexencode": HexEncoder{},
+ "hexdecode": HexDecoder{},
+ "unicodedecode": UnicodeDecode{},
+ "unicodeencodeall": UnicodeEncodeAll{},
+ "urlencode": URLEncoder{},
+ "urldecode": URLDecoder{},
+ "urlencodeall": URLEncoderAll{},
 }
 
 type Chain struct {

pkg/pencode/unicodedecode.go

@@ -0,0 +1,122 @@
+package pencode
+
+import (
+ "unicode"
+ "unicode/utf16"
+ "unicode/utf8"
+)
+
+type UnicodeDecode struct{}
+
+func (u UnicodeDecode) Encode(input []byte) ([]byte, error) {
+ return unquoteBytes(input), nil
+}
+
+func (u UnicodeDecode) HelpText() string {
+ return "Unicode escape string decode"
+}
+
+//This functionality is copied from encoding/json/decode.go with minor modifications
+func unquoteBytes(s []byte) []byte {
+ b := make([]byte, len(s)+2*utf8.UTFMax)
+ r := 0
+ w := copy(b, s[0:r])
+ for r < len(s) {
+ // Out of room? Can only happen if s is full of
+ // malformed UTF-8 and we're replacing each
+ // byte with RuneError.
+ if w >= len(b)-2*utf8.UTFMax {
+ nb := make([]byte, (len(b)+utf8.UTFMax)*2)
+ copy(nb, b[0:w])
+ b = nb
+ }
+ switch c := s[r]; {
+ case c == '\\':
+ r++
+ if r >= len(s) {
+ return b[0:w]
+ }
+ switch s[r] {
+ default:
+ return b[0:w]
+ case '"', '\\', '/', '\'':
+ b[w] = s[r]
+ r++
+ w++
+ case 'b':
+ b[w] = '\b'
+ r++
+ w++
+ case 'f':
+ b[w] = '\f'
+ r++
+ w++
+ case 'n':
+ b[w] = '\n'
+ r++
+ w++
+ case 'r':
+ b[w] = '\r'
+ r++
+ w++
+ case 't':
+ b[w] = '\t'
+ r++
+ w++
+ case 'u':
+ r--
+ rr := getu4(s[r:])
+ if rr < 0 {
+ return b[0:w]
+ }
+ r += 6
+ if utf16.IsSurrogate(rr) {
+ rr1 := getu4(s[r:])
+ if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
+ // A valid pair; consume.
+ r += 6
+ w += utf8.EncodeRune(b[w:], dec)
+ break
+ }
+ // Invalid surrogate; fall back to replacement rune.
+ rr = unicode.ReplacementChar
+ }
+ w += utf8.EncodeRune(b[w:], rr)
+ }
+ // ASCII
+ case c < utf8.RuneSelf:
+ b[w] = c
+ r++
+ w++
+ // Coerce to well-formed UTF-8.
+ default:
+ rr, size := utf8.DecodeRune(s[r:])
+ r += size
+ w += utf8.EncodeRune(b[w:], rr)
+ }
+ }
+ return b[0:w]
+}
+
+// getu4 decodes \uXXXX from the beginning of s, returning the hex value,
+// or it returns -1.
+func getu4(s []byte) rune {
+ if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
+ return -1
+ }
+ var r rune
+ for _, c := range s[2:6] {
+ switch {
+ case '0' <= c && c <= '9':
+ c = c - '0'
+ case 'a' <= c && c <= 'f':
+ c = c - 'a' + 10
+ case 'A' <= c && c <= 'F':
+ c = c - 'A' + 10
+ default:
+ return -1
+ }
+ r = r*16 + rune(c)
+ }
+ return r
+}

pkg/pencode/unicodeencodeall.go

@@ -0,0 +1,22 @@
+package pencode
+
+import (
+ "bytes"
+ "fmt"
+)
+
+type UnicodeEncodeAll struct{}
+
+func (u UnicodeEncodeAll) Encode(input []byte) ([]byte, error) {
+ var b bytes.Buffer
+ runes := []rune(string(input))
+ for _, r := range runes {
+ b.WriteString("\\u")
+ b.WriteString(fmt.Sprintf("%04x", int64(r)))
+ }
+ return b.Bytes(), nil
+}
+
+func (u UnicodeEncodeAll) HelpText() string {
+ return "Unicode escape string encode (all characters)"
+}