ghidra-master/Ghidra/Features/MicrosoftDmang/src/main/java/mdemangler/MDString.java
/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package mdemangler;

import java.nio.charset.Charset;

/**
 * This class represents "string" within a Microsoft mangled symbol.
 */
public class MDString extends MDParsableItem {
	private String name;
	private byte[] byteArray;
	private String byteString;
	private char charType;
	private int typeSize;
	private boolean crcPass;
	private int lenVal;
	private long crcVal;
	private boolean hasAddr = false;
	private long addrVal = 0;

	// TODO: Look into Ghidra types: AsciiDataType (replaced by charDataType?),
	//  WideChar16DataType, WideChar32DataType, and WideCharDataType.

	public MDString(MDMang dmang) {
		super(dmang);
	}

	@Override
	public void insert(StringBuilder builder) {
		// MDMANG SPECIALIZATION USED.
		dmang.insert(builder, this);
	}

	public boolean isUnicode() {
		return (charType == '1');
	}

	public byte[] getBytes() {
		return byteArray;
	}

	public int getLength() {
		return lenVal;
	}

	public String getName() {
		return name;
	}

	public boolean hasAddress() {
		return hasAddr;
	}

	public long getAddress() {
		return addrVal;
	}

	public String getString(Charset charset8, Charset charset16) {
		if (byteString == null) {
			int index;
			switch (typeSize) {
				case 2:
					byteString = new String(byteArray, charset16);
					break;
				case 1:
				default:
					byteString = new String(byteArray, charset8);
					break;
			}
			for (index = 0; index < byteString.length(); index++) {
				if (byteString.charAt(index) == '\u0000') {
					byteString = byteString.substring(0, index);
					break;
				}
			}
		}
		return byteString;
	}

	public boolean crcPass() {
		return crcPass;
	}

	// Information gleaned from lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-
	//  Mon-20150324/101952.html
	// '??_C@_' <char-type> <literal-length> <encoded-crc> <encoded-string> '@'
	// where:
	//  <char-type> = 0 if char
	//              = 1 if wchar_t
	//              = ??? for char16_t and char32_t
	//  <literal-length> = <non-negative integer>       # length of the literal
	//                                                  # The string literal does not consider
	//                                                     the NUL terminator byte(s) but the
	//                                                     mangling does.
	//                                                  # The length is in terms of bytes, not
	//                                                     characters
	//                                                  # mangleNumber(byteLength = charByteWidth)
	//                                                     ???
	//  <encoded-crc> = <hex digit>+ @                  # crc of the literal including
	//                                                     null-terminator
	//  <encoded-string> = <simple character>           # for an uninteresting character
	//                                                     [a-z|A-Z|0-9|_|$]
	//                   = ?$<hex digit> <hex digit>    # theses two nibbles encode the byte for
	//                                                     the character
	//                   = ?[a-z]                       # 0xe1 - 0xfa 
	//                   = ?[A-Z]                       # 0xc1 - 0xda 
	//                   = ?[0-9]                       # [,/\:. \n\t'-] 
	//                                                  # Has up to 32 characters (of the
	//                                                     character type).
	@Override
	protected void parseInternal() throws MDException {
		name = "";
		// Up to this point the following characters have been stripped: '??_C'
		if (dmang.getAndIncrement() != '@') {
			throw new MDException("MDString parse error: missing @");
		}
		if (dmang.getAndIncrement() != '_') {
			throw new MDException("MDString parse error: missing _");
		}
		charType = dmang.getAndIncrement();
		MDEncodedNumber len = new MDEncodedNumber(dmang);
		len.parse();
		lenVal = len.getValue().intValue();
		MDEncodedNumber crcNumber = new MDEncodedNumber(dmang);
		crcNumber.parse();
		crcVal = crcNumber.getValue().longValue();
		switch (charType) {
			case '0': // char string
				typeSize = 1;
				name = "`string'";
				break;
			case '1': // wchar_t string
				typeSize = 2;
				name = "`string'";
				break;
			default:
				typeSize = 1;
				name = "`string'";
				// name = "MDString: Microsoft string of unknown type: " + charType;
				break;
		}
		if ((lenVal % typeSize) != 0) {
			// error... which we are currently ignoring
		}
		parseByteArray();
		if (dmang.peek() != MDMang.DONE) {
			MDEncodedNumber addr = new MDEncodedNumber(dmang);
			addr.parse();
			addrVal = addr.getValue().longValue();
			hasAddr = true;
		}
		if (lenVal <= (32 * typeSize)) {
			CrcChecker checker = new CrcChecker();
			crcPass = checker.crcCheck(byteArray, crcVal, typeSize);
		}
		else {
			// Returning true for now, as we do not have the data needed to calculate the CRC.
			crcPass = true;
		}
	}

	private byte parseByte() throws MDException {
		byte b = 0;
		char c = dmang.getAndIncrement();
		if (Character.isLetter(c) || Character.isDigit(c) || c == '_' || c == '$') {
			b = (byte) c;
		}
		else if (c == '?') {
			if ((dmang.peek() == MDMang.DONE)) {
				throw new MDException("MDString parse error: not enough data");
			}
			c = dmang.getAndIncrement();
			if (c >= 'a' && c <= 'z') {
				b = (byte) (c - 'a' + 0xe1);
			}
			else if (c >= 'A' && c <= 'Z') {
				b = (byte) (c - 'A' + 0xc1);
			}
			else {
				switch (c) {
					case '0':
						b = (byte) (',');
						break;
					case '1':
						b = (byte) ('/');
						break;
					case '2':
						b = (byte) ('\\');
						break;
					case '3':
						b = (byte) (':');
						break;
					case '4':
						b = (byte) ('.');
						break;
					case '5':
						b = (byte) (' ');
						break;
					case '6':
						b = (byte) ('\n');
						break;
					case '7':
						b = (byte) ('\t');
						break;
					case '8':
						b = (byte) ('\'');
						break;
					case '9':
						b = (byte) ('-');
						break;
					case '$':
						if ((dmang.peek() == MDMang.DONE)) {
							throw new MDException("MDString parse error: not enough data");
						}
						c = dmang.getAndIncrement();
						if (c < 'A' || c > ('A' + 15)) {
							throw new MDException("MDString parse error: invalid hex code:" + c);
						}
						b = (byte) ((c - 'A') << 4);
						if ((dmang.peek() == MDMang.DONE)) {
							throw new MDException("MDString parse error: not enough data");
						}
						c = dmang.getAndIncrement();
						if (c < 'A' || c > ('A' + 15)) {
							throw new MDException("MDString parse error: invalid hex code:" + c);
						}
						b |= (byte) (c - 'A');
						break;
					default:
						throw new MDException("MDString parse error: invalid code2: " + c);
				}
			}
		}
		else {
			throw new MDException("MDString parse error: invalid code1:" + c);
		}
		return b;
	}

	private void parseByteArray() throws MDException {
		byteArray = new byte[lenVal];
		int index = 0;
		while ((dmang.peek() != '@') && (index < lenVal)) {
			byteArray[index++] = parseByte();
		}
		dmang.increment(); // Skip terminating '@'
	}

	/**
	 * This class is responsible for performing Cyclic Redundancy Check (CRC) calculations
	 * using the CRC-32 polynomial and prefill.
	 */
	private class CrcChecker {
		long crc;

		private long reflectBits(long val) {
			int i = 0;
			long newVal = 0L;
			for (i = 0; i < 32; i++) {
				newVal >>= 1;
				newVal |= val & 0X80000000L;
				val <<= 1;
			}
			return newVal;
		}

		private void crcCalc(byte val) {
			long longByte = val;
			for (int i = 0; i < 8; i++) {
				crc <<= 1;
				if ((((crc >> 32) ^ longByte) & 0x01L) != 0x00L) {
					crc ^= 0x04c11db7L; // xor with polynomial
				}
				longByte >>= 1;
			}
		}

		/**
		 * Performs the CRC calculation.
		 * @param bytes the array of bytes upon which to perform the calculation.
		 * @param crcTest the value to compare the result with.
		 * @return true if the calculation matches crcTest; false otherwise.
		 */
		private boolean crcCheck(byte[] bytes, long crcTest, int size) {
			int index;
			crc = 0xffffffffL;
			for (index = 0; index < bytes.length; index += size) {
				for (int internalIndex = size - 1; internalIndex >= 0; internalIndex--) {
					crcCalc(bytes[index + internalIndex]);
				}
			}
			crc &= 0xffffffffL;
			crc = reflectBits(crc);
			return (crc == crcTest);
		}
	}
}

/******************************************************************************/
/******************************************************************************/
