Wie zu entschlüsseln protobuf binary Antwort

UnknownFieldSet.parseFrom(msg).toString()

Dies wird Ihnen zeigen, die top-level-Felder. Leider kann Sie nicht wissen, die genauen details der Feld-Typen. long/int/bool/enum etc sind alle codiert, wie Varint und alle gleich Aussehen. Strings, byte-arrays und sub-Nachrichten, in der Länge getrennt und sind auch nicht zu unterscheiden.

Einige nützliche details hier: https://github.com/dcodeIO/protobuf.js/wiki/How-to-reverse-engineer-a-buffer-by-hand

Wenn Sie Folgen Sie den code in der UnknownFieldSet.mergeFrom() sehen Sie, wie Sie könnten versuchen, zu entschlüsseln sub-Nachrichten, und fallen wieder zurück an die Saiten, wenn das fehlschlägt - aber es ist nicht sehr zuverlässig.

Gibt es 2 Ersatz-Werte für die wiretype in der Protokoll - es wäre wirklich hilfreich gewesen, wenn google Sie benutzt hatte, eine dieser zu bezeichnen sub-Nachrichten. (Und die andere für null-Werte vielleicht.)

Hier einige sehr grobe Eilte code versucht, produzieren etwas nützliches für die Diagnose. Er rät, bei der Daten-Arten und im Falle von strings und sub-Nachrichten, gibt es beide Varianten in einigen Fällen. Sie Vertrauen nicht alle Werte ausgegeben:

public static String decodeProto(byte[] data, boolean singleLine) throws IOException {
    return decodeProto(ByteString.copyFrom(data), 0, singleLine);
}

public static String decodeProto(ByteString data, int depth, boolean singleLine) throws IOException {
    final CodedInputStream input = CodedInputStream.newInstance(data.asReadOnlyByteBuffer());
    return decodeProtoInput(input, depth, singleLine);
}

private static String decodeProtoInput(CodedInputStream input, int depth, boolean singleLine) throws IOException {
    StringBuilder s = new StringBuilder("{ ");
    boolean foundFields = false;
    while (true) {
        final int tag = input.readTag();
        int type = WireFormat.getTagWireType(tag);
        if (tag == 0 || type == WireFormat.WIRETYPE_END_GROUP) {
            break;
        }
        foundFields = true;
        protoNewline(depth, s, singleLine);

        final int number = WireFormat.getTagFieldNumber(tag);
        s.append(number).append(": ");

        switch (type) {
            case WireFormat.WIRETYPE_VARINT:
                s.append(input.readInt64());
                break;
            case WireFormat.WIRETYPE_FIXED64:
                s.append(Double.longBitsToDouble(input.readFixed64()));
                break;
            case WireFormat.WIRETYPE_LENGTH_DELIMITED:
                ByteString data = input.readBytes();
                try {
                    String submessage = decodeProto(data, depth + 1, singleLine);
                    if (data.size() < 30) {
                        boolean probablyString = true;
                        String str = new String(data.toByteArray(), Charsets.UTF_8);
                        for (char c : str.toCharArray()) {
                            if (c < '\n') {
                                probablyString = false;
                                break;
                            }
                        }
                        if (probablyString) {
                            s.append("\"").append(str).append("\" ");
                        }
                    }
                    s.append(submessage);
                } catch (IOException e) {
                    s.append('"').append(new String(data.toByteArray())).append('"');
                }
            break;
            case WireFormat.WIRETYPE_START_GROUP:
                s.append(decodeProtoInput(input, depth + 1, singleLine));
                break;
            case WireFormat.WIRETYPE_FIXED32:
                s.append(Float.intBitsToFloat(input.readFixed32()));
                break;
            default:
                throw new InvalidProtocolBufferException("Invalid wire type");
        }

    }
    if (foundFields) {
        protoNewline(depth - 1, s, singleLine);
    }
    return s.append('}').toString();
}

private static void protoNewline(int depth, StringBuilder s, boolean noNewline) {
    if (noNewline) {
        s.append(" ");
        return;
    }
    s.append('\n');
    for (int i = 0; i <= depth; i++) {
        s.append(INDENT);
    }
}

InformationsquelleAutor AutomatedMike