Капча

Она и не будет перекидывать)) Перекидывает на сервер наша капча, которая не выдается)))
Банжа всего лишь подключается к ней.

 

SrvGuardBungee

 

Это обычная банжа, она всем клиентам выдается
Капчи там нет.
Вот если 200 руб. в месяц платить будешь, то она сможет подключаться к капче.

 

((((( Пичалька((([DOUBLEPOST=1466806830,1466806740][/DOUBLEPOST]

А, смогу с****ить капчу? Если куплю за 200 руб

 

Да конечно. Покупай.

 

Ftp доступ даете?[DOUBLEPOST=1466807060,1466807027][/DOUBLEPOST]

Или-же сразу SSH?[DOUBLEPOST=1466807346][/DOUBLEPOST]

Тут код, он никуда не подключается, кто-то врет )))


AddressMetrics.class

Код:

package srvguard.proxy;

import java.time.temporal.TemporalUnit;
import java.time.temporal.ChronoUnit;
import java.time.temporal.Temporal;
import java.util.HashSet;
import java.time.Instant;
import io.netty.channel.Channel;
import java.util.Set;
import java.time.Duration;

public final class AddressMetrics
{
    public final double penaltyFactor;
    public final double maxFactor;
    public final Duration reconnectTime;
    public final int maxConnections;
    public final Object lockOn;
    private final Set<Channel> connected;
    private Instant lastConnected;
    private double factor;
    private Instant bannedUntil;
    private Instant verifiedUntil;
   
    public AddressMetrics(final double penaltyFactor, final double maxFactor, final Duration reconnectTime, final int maxConnections) {
        this.lockOn = new Object();
        this.penaltyFactor = penaltyFactor;
        if (penaltyFactor < 0.0) {
            throw new IllegalArgumentException("Penalty factor should be >= 0");
        }
        this.maxFactor = maxFactor;
        if (maxFactor < penaltyFactor || maxFactor < 1.0) {
            throw new IllegalArgumentException("Max factor should be bigger than penalty factor and 1.0");
        }
        this.reconnectTime = reconnectTime;
        if (reconnectTime.isNegative() || reconnectTime.isZero()) {
            throw new IllegalArgumentException("Reconnect time should be bigger than nothing");
        }
        if ((this.maxConnections = maxConnections) <= 0) {
            throw new IllegalArgumentException("Max connections should be bigger than nothing");
        }
        this.connected = new HashSet<Channel>(16);
    }
   
    public void closeConnections() {
        this.connected.forEach(Channel::close);
    }
   
    public double getFactor() {
        return this.factor;
    }
   
    public int getConnected() {
        return this.connected.size();
    }
   
    public boolean isBanned(final Instant now) {
        return this.bannedUntil != null && now.isBefore(this.bannedUntil);
    }
   
    public boolean isVerified(final Instant now) {
        return this.verifiedUntil != null && now.isBefore(this.verifiedUntil);
    }
   
    public ConnectResult registerConnection(final Channel channel) {
        final Instant now = Instant.now();
        this.factor = this.calcFactor(now, false);
        this.lastConnected = now;
        this.connected.add(channel);
        if (this.isBanned(now)) {
            return ConnectResult.BANNED;
        }
        if (this.connected.size() > this.maxConnections) {
            return ConnectResult.REACHED_MAX_CONNECTS;
        }
        return (this.factor >= this.penaltyFactor) ? ((this.factor >= this.maxFactor) ? ConnectResult.REACHED_MAX_FACTOR : ConnectResult.REACHED_PENALTY_FACTOR) : (this.isVerified(now) ? ConnectResult.VERIFIED : ConnectResult.OK);
    }
   
    public boolean registerDisconnection(final Channel channel) {
        return this.connected.remove(channel);
    }
   
    public double calcFactor(final Temporal instant, final boolean limitGrowing) {
        if (this.lastConnected == null) {
            return 0.0;
        }
        final double delta = Duration.between(instant, this.lastConnected).plus(this.reconnectTime).toNanos() / this.reconnectTime.toNanos();
        if (limitGrowing && delta >= 0.0) {
            return this.factor;
        }
        return Math.min(Math.max(this.factor + delta, 0.0), this.maxFactor);
    }
   
    public void setBannedUntil(final Instant instant) {
        this.verifiedUntil = null;
        this.bannedUntil = instant;
    }
   
    public void setVerifiedUntil(final Instant instant) {
        this.bannedUntil = null;
        this.verifiedUntil = instant;
    }
   
    public static Instant oneDay() {
        return Instant.now().plus(1L, (TemporalUnit)ChronoUnit.DAYS);
    }
   
    public enum ConnectResult
    {
        OK,
        REACHED_PENALTY_FACTOR,
        REACHED_MAX_FACTOR,
        REACHED_MAX_CONNECTS,
        BANNED,
        VERIFIED;
    }
}

AdressRegistry.class

Код:

package srvguard.proxy;

import java.io.FileWriter;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.io.IOException;
import java.time.LocalDateTime;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.BungeeCord;
import java.time.temporal.Temporal;
import java.util.Iterator;
import java.util.function.ToIntFunction;
import io.netty.channel.Channel;
import java.time.temporal.TemporalUnit;
import java.time.temporal.ChronoUnit;
import java.net.InetAddress;
import java.time.Instant;
import java.time.Duration;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;
import java.io.Writer;
import io.netty.util.AttributeKey;

public final class AddressRegistry
{
    public static final AddressRegistry INSTANCE;
    public static final AttributeKey<Boolean> VERIFIED_KEY;
    public static final AttributeKey<AddressMetrics> METRICS_KEY;
    private static final Writer WRITER;
    private final Map<String, AddressMetrics> metrics;
    private final AddressMetrics globalMetrics;
    private final Object globalMetricsLock;
    private boolean isAttacking;
   
    private AddressRegistry() {
        this.metrics = new ConcurrentHashMap<String, AddressMetrics>(1000);
        this.globalMetrics = new AddressMetrics(60.0, 72.0, Duration.ofSeconds(5L), Integer.MAX_VALUE);
        this.globalMetricsLock = new Object();
        this.isAttacking = false;
    }
   
    public int countAddresses() {
        return this.metrics.size();
    }
   
    public int countBanned(final Instant now) {
        return this.count(m -> m.isBanned(now));
    }
   
    public int countVerified(final Instant now) {
        return this.count(m -> m.isVerified(now));
    }
   
    public double getFactor() {
        return this.globalMetrics.getFactor();
    }
   
    public AddressMetrics metricsFor(final InetAddress address) {
        return this.metrics.computeIfAbsent(address.getHostAddress(), k -> new AddressMetrics(5.0, 10.0, Duration.of(60L, ChronoUnit.SECONDS), 3));
    }
   
    public boolean registerConnection(final Channel channel) {
        final InetAddress address = toAddress(channel.remoteAddress());
        final AddressMetrics metrics = this.metricsFor(address);
        final boolean verified;
        synchronized (metrics.lockOn) {
            final AddressMetrics.ConnectResult result = metrics.registerConnection(channel);
            switch (result) {
                case OK:
                case VERIFIED: {
                    break;
                }
                case REACHED_PENALTY_FACTOR: {
                    metrics.setVerifiedUntil(null);
                    metrics.closeConnections();
                    break;
                }
                case BANNED:
                case REACHED_MAX_FACTOR: {
                    return false;
                }
                case REACHED_MAX_CONNECTS: {
                    metrics.setBannedUntil(AddressMetrics.oneDay());
                    metrics.closeConnections();
                    return false;
                }
                default: {
                    throw new AssertionError((Object)"WTF?!");
                }
            }
            verified = (result == AddressMetrics.ConnectResult.VERIFIED);
        }
        channel.attr(AddressRegistry.METRICS_KEY).set(metrics);
        channel.attr(AddressRegistry.VERIFIED_KEY).set(verified);
        synchronized (this.globalMetricsLock) {
            this.globalMetrics.registerConnection(channel);
            this.forceUpdateGlobalMetrics();
        }
        return true;
    }
   
    public void registerDisconnection(final Channel channel) {
        final InetAddress address = toAddress(channel.remoteAddress());
        this.metricsFor(address).registerDisconnection(channel);
        synchronized (this.globalMetrics) {
            this.globalMetrics.registerDisconnection(channel);
        }
    }
   
    public boolean remove(final InetAddress address) {
        return this.metrics.remove(address) != null;
    }
   
    public int removeAll() {
        final int size = this.metrics.size();
        this.metrics.clear();
        return size;
    }
   
    private int count(final ToIntFunction<AddressMetrics> f) {
        int count = 0;
        for (final AddressMetrics m : this.metrics.values()) {
            synchronized (m.lockOn) {
                count += f.applyAsInt(m);
            }
        }
        return count;
    }
   
    private void forceUpdateGlobalMetrics() {
        final Instant now = Instant.now();
        final boolean nowIsAttacking = this.globalMetrics.calcFactor(now, true) >= this.globalMetrics.penaltyFactor;
        if (this.isAttacking != nowIsAttacking) {
            this.isAttacking = nowIsAttacking;
            if (nowIsAttacking) {
                BungeeCord.SRVGUARD_ENABLED.set(true);
                BungeeCord.getInstance().broadcast(ChatColor.RED + "SRVGuard \u0444\u0438\u043a\u0441\u0438\u0440\u0443\u0435\u0442 \u0430\u0442\u0430\u043a\u0443 \u0431\u043e\u0442\u043e\u0432 \u043d\u0430 \u0441\u0435\u0440\u0432\u0435\u0440");
            }
            else {
                BungeeCord.getInstance().broadcast(ChatColor.GREEN + "SRVGuard \u0443\u0441\u043f\u0435\u0448\u043d\u043e \u043e\u0442\u0440\u0430\u0437\u0438\u043b \u0430\u0442\u0430\u043a\u0443 \u0431\u043e\u0442\u043e\u0432 \u043d\u0430 \u0441\u0435\u0440\u0432\u0435\u0440");
            }
            try {
                AddressRegistry.WRITER.write(LocalDateTime.now().toString() + ' ' + (nowIsAttacking ? "Attack started" : "Attack ended") + '\n');
                AddressRegistry.WRITER.flush();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
   
    public static void logBan(final InetAddress address, final int reason) {
        try {
            AddressRegistry.WRITER.write(String.format("%s %s banned by captcha: 0x%08X%n", LocalDateTime.now().toString(), address, reason));
            AddressRegistry.WRITER.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
   
    public static void startGlobalMetricsUpdater() {
        final Thread thread = new Thread(new GlobalMetricsUpdater(AddressRegistry.INSTANCE), "Global Metrics Updater");
        thread.setDaemon(true);
        thread.start();
    }
   
    private static InetAddress toAddress(final SocketAddress address) {
        return ((InetSocketAddress)address).getAddress();
    }
   
    public static boolean isVerified(final Channel channel) {
        return channel.attr(AddressRegistry.VERIFIED_KEY).get();
    }
   
    public static void setVerified(final Channel channel) {
        final AddressMetrics metrics = channel.attr(AddressRegistry.METRICS_KEY).get();
        synchronized (metrics.lockOn) {
            metrics.setVerifiedUntil(AddressMetrics.oneDay());
        }
    }
   
    public static void setBanned(final Channel channel) {
        final AddressMetrics metrics = channel.attr(AddressRegistry.METRICS_KEY).get();
        synchronized (metrics.lockOn) {
            metrics.setBannedUntil(AddressMetrics.oneDay());
            metrics.closeConnections();
        }
    }
   
    static {
        INSTANCE = new AddressRegistry();
        VERIFIED_KEY = AttributeKey.newInstance("verified");
        METRICS_KEY = AttributeKey.newInstance("metrics");
        try {
            WRITER = new FileWriter("attacks.log", true);
        }
        catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
   
    private static class GlobalMetricsUpdater implements Runnable
    {
        private final AddressRegistry registry;
       
        public GlobalMetricsUpdater(final AddressRegistry registry) {
            this.registry = registry;
        }
       
        @Override
        public void run() {
            while (BungeeCord.getInstance().isRunning) {
                try {
                    Thread.sleep(5000L);
                }
                catch (InterruptedException e) {
                    break;
                }
                synchronized (this.registry.globalMetricsLock) {
                    this.registry.forceUpdateGlobalMetrics();
                }
            }
        }
    }
}

 

Ну да , там целая капча встроена ахахаха. Мечтай)

 

Пичалька, кароч куплю капчу у Srv

 

Спойлер

 

у спигот есть капча бесплатная,если бы были знания в java можно было бы поставить приоритет на первое место,создать лист базу которую заблокировало,дальше таймаут блокировки а то она на вечно банит) мощная штука

 

че сразу не фотошоп?)

 

Все капчезащиты обходятся в 50 строк кода, мы уже показывали это на живом(теперь уже мертвом) примере

если бы

 

Ухади! GG не звали!

 

GG норм как раз

 

Ниэээт меня гаст послал !11

 

ГГ норм так, был у меня)

 

Конкуренция, ну или как способ самоутверждения у школьников

 

мда дела..

 

+++[DOUBLEPOST=1472061894,1467110242][/DOUBLEPOST]

Я купил srv у вас на сайте со скидкой 1 рубыль, и он пишет в панели уже 10 минут ожидайте. ЧТО МНЕ ДЕЛАТЬ