@RequestMapping("/{userPseudo}/validateStep4")
  public ResponseEntity<Void> validateStep4(
      @PathVariable("userPseudo") String userPseudo,
      @RequestParam("userHostAndPort") String userHostAndPort) {
    log.info("Validation step 4 for player {} with data {}", userPseudo, userHostAndPort);

    ResponseEntity<Void> result = new ResponseEntity<Void>(HttpStatus.BAD_REQUEST);

    String url = "http://" + userHostAndPort + "/zen/env";

    ResponseEntity<String> responseEntityShouldFail =
        restTemplate.exchange(
            url, HttpMethod.GET, new HttpEntity<>(new HttpHeaders()), String.class);

    byte[] encodedAuth = Base64.encodeBase64("zenika:technozaure".getBytes());
    String authHeader = "Basic " + new String(encodedAuth);

    HttpHeaders headers = new HttpHeaders();
    headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
    headers.set("Authorization", authHeader);
    HttpEntity<String> entity = new HttpEntity<>(headers);

    ResponseEntity<String> responseEntityShouldSucceed =
        restTemplate.exchange(url, HttpMethod.GET, entity, String.class);

    if (responseEntityShouldFail.getStatusCode() != HttpStatus.OK
        && responseEntityShouldSucceed.getStatusCode() == HttpStatus.OK) {
      gameStepRepository.save(new GameStep(userPseudo, Step._4));
      result = new ResponseEntity<Void>(HttpStatus.OK);
      broadcastGameStatus();
    }

    return result;
  }
Exemple #2
0
  public static String zip(String param) {
    try {
      byte[] unzip = param.getBytes("UTF-8");

      ByteArrayInputStream bif = new ByteArrayInputStream(unzip);
      ByteArrayOutputStream zipbof = new ByteArrayOutputStream();
      //			DeflaterOutputStream dos = new DeflaterOutputStream(zipbof);
      GZIPOutputStream gos = new GZIPOutputStream(zipbof);
      int position = 0;

      for (int read_byte = 0; (read_byte = bif.read()) != -1; position++) {
        //				dos.write(read_byte);
        gos.write(read_byte);
      }

      //			dos.finish();
      gos.finish();
      zipbof.flush();

      byte[] zipbyteArray = zipbof.toByteArray();
      //			return new sun.misc.BASE64Encoder().encode(zipbyteArray);
      return Base64.encodeBase64String(zipbyteArray);
    } catch (Exception ex) {
      return null;
    }
  }
  @POST
  @Path("/uploadTone")
  @Consumes("application/json")
  public void uploadTone(String file) {
    File someFile = new File("E:\\recording.3gp");
    JSONObject obj;
    String fileStream;
    byte[] fileBytes;
    BufferedOutputStream bos;
    try {
      obj = new JSONObject(file);
      fileStream = obj.getString("name_tone");
      fileBytes = Base64.decodeBase64(fileStream.getBytes());

      System.out.println(fileBytes);

      bos = new BufferedOutputStream(new FileOutputStream("E:\\recording.3gp"));
      bos.write(fileBytes);
      bos.flush();
      bos.close();

    } catch (Exception e) {
      System.out.println(e.getMessage());
      e.printStackTrace();
    }
  }
 private BasicCredentials(String aMethod, String aUsername, String aPassword) {
   method = aMethod;
   username = aUsername;
   password = aPassword;
   String userCredentials = username + ":" + password;
   byte[] credentialsBytes = userCredentials.getBytes(B2CConverter.ISO_8859_1);
   String base64auth = Base64.encodeBase64String(credentialsBytes);
   credentials = method + " " + base64auth;
 }
 public Map<String, String> parseTopParameters(String strTopParams, String encode) {
   if (strTopParams == null) return null;
   if (encode == null) encode = "GBK";
   String keyValues = null;
   try {
     keyValues = new String(Base64.decodeBase64(strTopParams.getBytes(encode)), encode);
   } catch (UnsupportedEncodingException e) {
     logger.error(e.getMessage(), e);
   }
   String[] kvPairs = keyValues.split("\\&");
   Map<String, String> map = new HashMap<String, String>();
   for (String kv : kvPairs) {
     String[] s = kv.split("\\=");
     if (s == null || s.length != 2) return null;
     map.put(s[0], s[1]);
   }
   return map;
 }
Exemple #6
0
  public String EncryptText(String RawText) {
    String EncText = "";
    byte[] keyArray = new byte[24];
    byte[] temporaryKey;
    String key = "developersnotedotcom";
    byte[] toEncryptArray = null;

    try {

      toEncryptArray = RawText.getBytes("UTF-8");
      MessageDigest m = MessageDigest.getInstance("MD5");
      temporaryKey = m.digest(key.getBytes("UTF-8"));

      if (temporaryKey.length < 24) // DESede require 24 byte length key
      {
        int index = 0;
        for (int i = temporaryKey.length; i < 24; i++) {
          keyArray[i] = temporaryKey[index];
        }
      }

      Cipher c = Cipher.getInstance("DESede/CBC/PKCS5Padding");
      c.init(
          Cipher.ENCRYPT_MODE,
          new SecretKeySpec(keyArray, "DESede"),
          new IvParameterSpec(sharedvector));
      byte[] encrypted = c.doFinal(toEncryptArray);
      EncText = Base64.encodeBase64String(encrypted);

    } catch (NoSuchAlgorithmException
        | UnsupportedEncodingException
        | NoSuchPaddingException
        | InvalidKeyException
        | InvalidAlgorithmParameterException
        | IllegalBlockSizeException
        | BadPaddingException NoEx) {
      JOptionPane.showMessageDialog(null, NoEx);
    }

    return EncText;
  }
Exemple #7
0
  public static String unzip(String param) {
    try {
      //			byte[] zipArray = new sun.misc.BASE64Decoder().decodeBuffer(param);
      byte[] zipArray = Base64.decodeBase64(param);

      ByteArrayInputStream bif = new ByteArrayInputStream(zipArray);
      //			InflaterInputStream iis = new InflaterInputStream(bif);
      GZIPInputStream gis = new GZIPInputStream(bif);
      ByteArrayOutputStream unZipbof = new ByteArrayOutputStream();
      int position = 0;
      //			for (int read_byte = 0; (read_byte = iis.read()) != -1; position++) {
      for (int read_byte = 0; (read_byte = gis.read()) != -1; position++) {
        unZipbof.write(read_byte);
      }
      unZipbof.flush();

      byte[] unZipbyteArray = unZipbof.toByteArray();
      String returnUnZipString = new String(unZipbyteArray, "UTF-8");
      return returnUnZipString;
    } catch (Exception ex) {
      return null;
    }
  }
Exemple #8
0
  /**
   * Handles the HTTP <code>POST</code> method.
   *
   * @param request servlet request
   * @param response servlet response
   * @throws ServletException if a servlet-specific error occurs
   * @throws IOException if an I/O error occurs
   */
  @Override
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    //        String currentPath = getServletContext().getResource("/").getPath();
    //        File dir = new File(currentPath);
    //        String dirName = dir.getParentFile().getParentFile().getAbsolutePath();
    //        String path = dirName + "/uploads";

    //        String contextPath = request.getContextPath();
    //        String projectFolderPath = getProjectFolderPath(contextPath);
    //        String savingPath = projectFolderPath + OpenCVLoader.fileSeparator +
    // OpenCVLoader.imagesFolder;

    String savingPath = ImageUtils.getImageSavingDirectory(request);

    response.setContentType("application/json");
    PrintWriter out = response.getWriter();

    boolean isMultipart = ServletFileUpload.isMultipartContent(request);

    if (isMultipart) {
      // Create a factory for disk-based file items
      FileItemFactory factory = new DiskFileItemFactory();

      // Create a new file upload handler
      ServletFileUpload upload = new ServletFileUpload(factory);

      try {
        // Parse the request
        List<FileItem> items = upload.parseRequest(request);

        Iterator<FileItem> iterator = items.iterator();

        while (iterator.hasNext()) {

          FileItem item = iterator.next();

          if (item.isFormField()) {

            String name = item.getFieldName();
            String value = item.getString();

            if (value.contains("data:image/png;base64,")) {
              value = value.substring("data:image/png;base64,".length());
            } else if (value.contains("data:image/svg+xml;base64,")) {
              value = value.substring("data:image/svg+xml;base64,".length());
            } else if (value.contains("data:image/jpeg;base64,")) {
              value = value.substring("data:image/jpeg;base64,".length());
            } else if (value.contains("data:image/gif;base64,")) {
              value = value.substring("data:image/gif;base64,".length());
            }

            byte[] contentData = value.getBytes();
            byte[] decodedData = Base64.decodeBase64(contentData);

            String fileName = savingPath + "/" + name + ".png";

            FileOutputStream fos = new FileOutputStream(fileName);
            fos.write(decodedData);
            fos.flush();
            fos.close();

            //                        String rects = classes.FaceDetector.detectFace(fileName);

            //                        out.println(rects + " faces detected!!!");

            //                        out.write(rects);

            out.write("Image imported");
          }
        }

      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }
  public Result send(CouponReqVO couponReq, HttpServletRequest request, boolean isReal) {
    SendVO sendVO = new SendVO();

    if (couponReq.getMid() == null || couponReq.getPassword() == null) {
      return new Result(100, "필수파라메터 부족");
    }

    // 판매업체 mid와 password가 일치하는지 확인
    SellerVO inSeller = new SellerVO();
    inSeller.setMid(couponReq.getMid());
    inSeller.setPassword(couponReq.getPassword());
    SellerVO seller = adminService.getSeller(inSeller);
    if (seller == null) {
      return new Result(200, "등록된 판매업체가 아닙니다.");
    }
    sendVO.setSeller_id(seller.getSeller_id());

    // 등록된 IP인지 확인
    String allowed_ip = seller.getAllowed_ip();
    if (!allowed_ip.contains(request.getRemoteAddr())) {
      logger.debug("ip:" + request.getRemoteAddr());
      return new Result(300, "허용된 IP가 아닙니다.");
    }

    // 상품 정보 확인
    GoodsVO inGoods = new GoodsVO();
    inGoods.setGoods_code(couponReq.getGoods_code());
    inGoods.setReal(isReal); // 실상품 or 테스트 상품 구분
    GoodsVO goods = adminService.getGoods(inGoods);
    if (goods == null) {
      return new Result(400, "등록된 상품코드가 아닙니다.");
    }
    sendVO.setGoods_id(goods.getGoods_id());
    // 판매가격은 상품정보의 sell_price로 세팅. 판매업체에게 제공받지 않는다.
    sendVO.setSell_price(goods.getSell_price());

    // 발송정보 세팅
    sendVO.setGoods_count("1"); // 상품 수량은 1로 고정
    sendVO.setRecv_phone(couponReq.getRecv_phone());
    sendVO.setSend_phone(couponReq.getSend_phone());
    sendVO.setTr_id(couponReq.getTr_id());
    sendVO.setMsg(couponReq.getMessage());

    restTemplate = new RestTemplate();
    params = new LinkedMultiValueMap<String, String>();
    UriComponents uriComponents;
    String baseUrl = "";
    // M12 handling
    if (goods.getProvider() == 1) {
      params.add("goods_code", couponReq.getGoods_code());
      params.add("goods_count", sendVO.getGoods_count()); // 상품 수량 1로 고정
      params.add("send_phone", couponReq.getSend_phone());
      params.add("recv_phone", couponReq.getRecv_phone());
      params.add("tr_id", couponReq.getTr_id());
      params.add("userid", "hlint");
      params.add("sell_price", sendVO.getSell_price()); // 상품 판매가격으로 고정
      params.add("msg", couponReq.getMessage());

      if (isReal) {
        baseUrl = "http://web6.m12.co.kr:12101/app/order_send.php";
      } else {
        baseUrl = "http://web6.m12.co.kr:12101/app/dev/order_send.php";
      }

      uriComponents = UriComponentsBuilder.fromHttpUrl(baseUrl).queryParams(params).build();
      String value = uriComponents.getQuery();
      String key = "HLINTNLE54A3I2O1";
      String initVector = "J0S9O8T7USJFDLSX";
      logger.debug(value);

      try {

        IvParameterSpec iv = new IvParameterSpec(initVector.getBytes("UTF-8"));
        SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");

        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);

        byte[] encrypted = cipher.doFinal(value.getBytes());
        String strpara = Base64.encodeBase64String(encrypted);
        params.clear();
        params.add("marketcode", "HLINTNL01");
        params.add("strpara", strpara);
        uriComponents = UriComponentsBuilder.fromHttpUrl(baseUrl).queryParams(params).build();
        logger.debug(uriComponents.toUriString());
        String strResult = restTemplate.getForObject(uriComponents.toUriString(), String.class);
        SAXBuilder builder = new SAXBuilder();
        Document document = (Document) builder.build(new StringReader(strResult));
        Element rootNode = document.getRootElement();
        logger.debug(rootNode.getName());
        String resultCode = rootNode.getChild("RESULT_CODE", rootNode.getNamespace()).getText();
        String statusCode = rootNode.getChild("STATUS_CODE", rootNode.getNamespace()).getText();

        // 쿠폰 발송 상태 저장
        sendVO.setResult_code(resultCode);
        sendVO.setStatus_code(statusCode);

        sendVO.setReal(isReal);
        logger.debug(sendVO.toString());
        adminService.addSend(sendVO);

        return new Result(Integer.parseInt(resultCode), statusCode);
      } catch (Exception e) {
        e.printStackTrace();
        return new Result(500, "내부 오류가 발생하였습니다.");
      }
    }
    // Coup handling, 문서 2.18 구현
    else if (goods.getProvider() == 2) {
      params.add("CODE", "0424");
      params.add("PASS", "hlint123");
      params.add("COUPONCODE", couponReq.getGoods_code());
      params.add("SEQNUMBER", couponReq.getTr_id());
      params.add("QTY", sendVO.getGoods_count()); // 상품수량은 1개
      params.add("HP", couponReq.getRecv_phone());
      params.add("CALLBACK", couponReq.getSend_phone());
      params.add("TITLE", "");
      params.add("ADDMSG", couponReq.getMessage());
      params.add("SELPRICE", sendVO.getSell_price()); // 상품 가격 세팅

      // logger.debug(params.toString());
      if (isReal) {
        baseUrl = "http://v3api.inumber.co.kr/serviceapi_02.asmx/ServiceCreateSendMuch";
      } else {
        baseUrl = "http://issuev3apitest.m2i.kr:9999/serviceapi_02.asmx/ServiceCreateSendMuch";
      }

      try {
        uriComponents = UriComponentsBuilder.fromHttpUrl(baseUrl).queryParams(params).build();
        logger.debug(uriComponents.toUriString());
        String strResult = restTemplate.getForObject(uriComponents.toUriString(), String.class);
        logger.debug("strResult:" + strResult);
        SAXBuilder builder = new SAXBuilder();
        Document document = (Document) builder.build(new StringReader(strResult));
        Element rootNode = document.getRootElement();

        String resultCode = rootNode.getChild("RESULTCODE", rootNode.getNamespace()).getText();
        String resultMsg = rootNode.getChild("RESULTMSG", rootNode.getNamespace()).getText();

        // 쿠폰 발송 상태 저장
        sendVO.setResult_code(resultCode);
        sendVO.setStatus_code(resultMsg);

        // 쿠폰번호와 핀번호 저장
        if ("00".equals(resultCode)) {
          Element List = rootNode.getChild("LIST", rootNode.getNamespace());
          List couponList = List.getChildren("GCOUPONLIST", rootNode.getNamespace());
          // 한건만 보내므로 루프를 돌리지않고 한건만 저장
          Element node = (Element) couponList.get(0);
          String couponNumber = node.getChildText("COUPONNUMBER", rootNode.getNamespace());
          String pinNumber = node.getChildText("PINNUMBER", rootNode.getNamespace());
          sendVO.setCouponnumber(couponNumber);
          sendVO.setPinnumber(pinNumber);
        }
        sendVO.setReal(isReal);

        logger.debug(sendVO.toString());
        adminService.addSend(sendVO);

        return new Result(Integer.parseInt(resultCode), resultMsg);
      } catch (Exception e) {
        e.printStackTrace();
        return new Result(100, "Coupon failed");
      }
    }

    return new Result(500, "내부 오류가 발생하였습니다.");
  }
 public static String getSalt() {
   Random r = new SecureRandom();
   byte[] saltBytes = new byte[32];
   r.nextBytes(saltBytes);
   return Base64.encodeBase64String(saltBytes);
 }
  @Override
  public boolean authenticate(Request request, HttpServletResponse response, LoginConfig config)
      throws IOException {

    if (checkForCachedAuthentication(request, response, true)) {
      return true;
    }

    MessageBytes authorization =
        request.getCoyoteRequest().getMimeHeaders().getValue("authorization");

    if (authorization == null) {
      if (log.isDebugEnabled()) {
        log.debug(sm.getString("authenticator.noAuthHeader"));
      }
      response.setHeader("WWW-Authenticate", "Negotiate");
      response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
      return false;
    }

    authorization.toBytes();
    ByteChunk authorizationBC = authorization.getByteChunk();

    if (!authorizationBC.startsWithIgnoreCase("negotiate ", 0)) {
      if (log.isDebugEnabled()) {
        log.debug(sm.getString("spnegoAuthenticator.authHeaderNotNego"));
      }
      response.setHeader("WWW-Authenticate", "Negotiate");
      response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
      return false;
    }

    authorizationBC.setOffset(authorizationBC.getOffset() + 10);

    byte[] decoded =
        Base64.decodeBase64(
            authorizationBC.getBuffer(), authorizationBC.getOffset(), authorizationBC.getLength());

    if (getApplyJava8u40Fix()) {
      SpnegoTokenFixer.fix(decoded);
    }

    if (decoded.length == 0) {
      if (log.isDebugEnabled()) {
        log.debug(sm.getString("spnegoAuthenticator.authHeaderNoToken"));
      }
      response.setHeader("WWW-Authenticate", "Negotiate");
      response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
      return false;
    }

    LoginContext lc = null;
    GSSContext gssContext = null;
    byte[] outToken = null;
    Principal principal = null;
    try {
      try {
        lc = new LoginContext(getLoginConfigName());
        lc.login();
      } catch (LoginException e) {
        log.error(sm.getString("spnegoAuthenticator.serviceLoginFail"), e);
        response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        return false;
      }

      Subject subject = lc.getSubject();

      // Assume the GSSContext is stateless
      // TODO: Confirm this assumption
      final GSSManager manager = GSSManager.getInstance();
      // IBM JDK only understands indefinite lifetime
      final int credentialLifetime;
      if (Globals.IS_IBM_JVM) {
        credentialLifetime = GSSCredential.INDEFINITE_LIFETIME;
      } else {
        credentialLifetime = GSSCredential.DEFAULT_LIFETIME;
      }
      final PrivilegedExceptionAction<GSSCredential> action =
          new PrivilegedExceptionAction<GSSCredential>() {
            @Override
            public GSSCredential run() throws GSSException {
              return manager.createCredential(
                  null, credentialLifetime, new Oid("1.3.6.1.5.5.2"), GSSCredential.ACCEPT_ONLY);
            }
          };
      gssContext = manager.createContext(Subject.doAs(subject, action));

      outToken = Subject.doAs(lc.getSubject(), new AcceptAction(gssContext, decoded));

      if (outToken == null) {
        if (log.isDebugEnabled()) {
          log.debug(sm.getString("spnegoAuthenticator.ticketValidateFail"));
        }
        // Start again
        response.setHeader("WWW-Authenticate", "Negotiate");
        response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
        return false;
      }

      principal =
          Subject.doAs(
              subject,
              new AuthenticateAction(context.getRealm(), gssContext, storeDelegatedCredential));

    } catch (GSSException e) {
      if (log.isDebugEnabled()) {
        log.debug(sm.getString("spnegoAuthenticator.ticketValidateFail"), e);
      }
      response.setHeader("WWW-Authenticate", "Negotiate");
      response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
      return false;
    } catch (PrivilegedActionException e) {
      Throwable cause = e.getCause();
      if (cause instanceof GSSException) {
        if (log.isDebugEnabled()) {
          log.debug(sm.getString("spnegoAuthenticator.serviceLoginFail"), e);
        }
      } else {
        log.error(sm.getString("spnegoAuthenticator.serviceLoginFail"), e);
      }
      response.setHeader("WWW-Authenticate", "Negotiate");
      response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
      return false;
    } finally {
      if (gssContext != null) {
        try {
          gssContext.dispose();
        } catch (GSSException e) {
          // Ignore
        }
      }
      if (lc != null) {
        try {
          lc.logout();
        } catch (LoginException e) {
          // Ignore
        }
      }
    }

    // Send response token on success and failure
    response.setHeader("WWW-Authenticate", "Negotiate " + Base64.encodeBase64String(outToken));

    if (principal != null) {
      register(request, response, principal, Constants.SPNEGO_METHOD, principal.getName(), null);

      Pattern p = noKeepAliveUserAgents;
      if (p != null) {
        MessageBytes ua = request.getCoyoteRequest().getMimeHeaders().getValue("user-agent");
        if (ua != null && p.matcher(ua.toString()).matches()) {
          response.setHeader("Connection", "close");
        }
      }
      return true;
    }

    response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
    return false;
  }