sudoSoooooo

[오류노트] 샤오미 온습도계(LYWSD03MMC) 2세대 지그비로 바꾸기

imSoo — Mon, 30 Mar 2026 16:19:29 +0900

problem

샤오미 블루투스 2세대는 블루투스 연동으로 샤오미 미 홈 앱으로 원격 모니터링 할 수 있습니다.

하지만 스마트 싱스를 이용해서 자동화를 하기 위해서는 블루투스를 Zigbee 로 바꿔 스마트 싱스에 연결 시킬 수 있어야 합니다.

이 곳 저곳 팁이 많지만 몇번의 시도를 하다가 벽돌되서 버렸던 경험이 있어서 글로 남겨 봅니다 ㅎㅎ...

solution

준비물

1. 블루투스 연결 가능한 PC - 맥북은 M1 은 안되고 M4 에서는 동작 확인 했습니다.

2. 샤오미 온습도계 2세대(LYWSD03MMC)

3. 핸드폰

온습도계 토큰 추출

기기 토큰을 추출 하기 위해서, 샤오미 미 홈 앱에 들어가서 기기 등록을 해줍니다.

오른쪽 + 버튼 -> 기기추가 -> 온습도 센서 -> Mi 블루투스 온습도계2

(가끔 바로 잡히지 않아 여러번 해야 잡히는 경우가 있었습니다.)

기기 등록 완료 후, PC 로 갑니다.

https://github.com/PiotrMachowski/Xiaomi-cloud-tokens-extractor

GitHub - PiotrMachowski/Xiaomi-cloud-tokens-extractor: This tool retrieves tokens for all devices connected to Xiaomi cloud and

This tool retrieves tokens for all devices connected to Xiaomi cloud and encryption keys for BLE devices. - PiotrMachowski/Xiaomi-cloud-tokens-extractor

github.com

에 들어가서 토큰 추출 할 exe 또는 파이썬 파일을 받아줍니다.

윈도우는 exe 파일 실행

아래는 Mac OS 용 입니다.

터미널을 엽니다. (homebrew 가 설치 되어 있어야 합니다)

한줄 한줄 복사해서 명령을 실행 합니다.

# homebrew 로 wget 설치
brew install wget
# homebrew 로 파이썬 설치
brew install python
# wget 으로 파일 다운로드
wget https://github.com/PiotrMachowski/Xiaomi-cloud-tokens-extractor/releases/latest/download/token_extractor.zip\nunzip token_extractor.zip -d token_extractor\ncd token_extractor
# 다운로드된 파일로 이동
cd token_extractor
# 파이썬으로 인스톨
pip3 install -r requirements.txt\npython3 token_extractor.py
pip3 install -r requirements.txt --break-system-packages
python3 token_extractor.py

다 되면 아래와 같은 화면이 뜰텐데요.

1. p 를 입력해 줍니다.

2. 샤오미 로그인 Email, 비밀번호를 입력

3. 캡차 인증 (대소문자 구별)

4. 이메일 2단계인증

5. server 를 선택하라고 나오는데, 무시를 합시다 (엔터)

위 사진과 같이 나오면, 우리가 필요한건 ID, Token, BLDXXX 이 세개를 어딘가에 복사해둡니다.

지그비 전환

브라우저 블루투스 기능 활성화

크롬 chrome://flags/#enable-experimental-web-platform-features

오페라 Opera://flags/#enable-experimental-web-platform-features

엣지 edge://flags/#enable-experimental-web-platform-features

웨일 whale://flags/#enable-experimental-web-platform-features

주소창에 검색하면 각 브라우저에 맞게 setting 을 변경 할 수 있는 창이 뜹니다.

크롬기준 위 사진을 "사용 가능" 으로 변경 후 새로고침을 해줍니다.

https://pvvx.github.io/ATC_MiThermometer/TelinkMiFlasher.html

위 사이트로 접속 후

Filter 에 LYWDS03 을 입력 후

Connect 버튼을 누르면 검색을 시작 합니다.

필터에 잡힌걸 페어링 해줍니다.

위에서 추출한 토큰들을 입력해줍니다.

차례대로 디바이스 ID, 토큰, BLDXX 는 bind Key 에 넣어줍니다.

잠시 후 완료되면 커넥트가 끊어

지는데, 다시 커넥트 해줍니다.

다시 커넥트 해줄땐 filter 에 있는 LYWDS03 를 지우고 ATC 로 변경 합니다.

다시 검색을 하면 ATCXXX 로 이름이 바뀌어 검색 됩니다.

이어서 8번을 누른 후 다시 Start Flashing 을 눌러주면 끝이 납니다.

[Spring/Kotlin] 애드몹 광고 보상 - 서버 검증 SSV

imSoo — Fri, 20 Mar 2026 10:09:34 +0900

Google 애드몹 광고단위에는 배너형 보상형 등.. 광고들이 있다.

오늘은 그것들 중 보상형 광고 (광고영상, 광고게임) 후, 이것을 서버측에서 검증 하는 방법을 적어보고자 한다.

Problem

"부탁해" 에서는 광고 후,

"마카다미아 2배속", "돼지 먹이주기" 보상을 제공 하는데, 이를 사용자가 실제로 광고를 정상적으로 시청 했는지 검증하는 도구가 필요 했다.

애드몹에서는 이를 위해 SSV 기능을 제공한다.

Solution

https://developers.google.com/admob/android/ssv?hl=ko

서버 측 인증 (SSV) 콜백 확인 | Android | Google for Developers

Android용 Google 모바일 광고 SDK를 사용하여 보상형 광고의 서버 측 확인 (SSV) 콜백을 확인합니다.

developers.google.com

Java Tink 라이브러리를 사용해서 검증을 할 수 있다.

순서

1. 사용자 광고 시청 -> 광고시청완료 ->

2. 클라이언트가 애드몹 서버로 (광고 시청 완료 됨 - 커스텀키 포함) 요청 ->

3. 애드몹이 my서버로 (광고 시청 완료됨 - 커스텀키 포함 ) 요청 ->

4. 클라이언트 - 서버로 광고 완료 요청(커스텀키 포함) ->

5. 2번에서 보낸 커스텀 키를 서버에서 검증 ->

6. 보상지급

코드를 보자

의존성 추가 ㄱㄱ

(필자는 Kotlin 을 사용 중..)

implementation("com.google.crypto.tink:apps-rewardedads:1.14.0")

애드몹 -> my서버로 들어오는 요청 (3번)

private val adDoneKey = "ad:ssv:done:"
 
fun processReward(fullUrl: String, queryParam: String): Boolean {
    try {
    //쿼리 스트링 해체
        val params = parseQueryString(queryParam)
        // 클라이언트에서 애드몹 서버로 보낸 customData 가 여기로 들어옵니다.
        val sessionId = params["custom_data"] ?: return false
        // url 검증
        verifier.verify(fullUrl)
        
        // 중복된 SessionId 가 있다면 그냥 true
        val ssvKey = "$adDoneKey$sessionId"
        val first = redisTemplate.opsForValue().setIfAbsent(ssvKey, "1", Duration.ofMinutes(5))
        if (first != true) {
            return true
        }

        // Redis 를 이용하여 클라이언트에서 애드몹으로 보낸 Session Key 를 저장 해줍니다.
        val tempKey = "$adsRewardKey$sessionId"
        redisTemplate.opsForValue().set(tempKey, "1", Duration.ofMinutes(30))
        
        return true
    } catch (e: Exception) {
        log.error("SSV Verification Failed", e)
        return false
    }
}
    
// 쿼리 스트링 해체 작업
private fun parseQueryString(query: String): Map<String, String> {
    return query.split("&").associate {
        val (key, value) = it.split("=").let { pair ->
            pair[0] to (pair.getOrNull(1) ?: "")
        }
        key to java.net.URLDecoder.decode(value, "UTF-8")
    }
}

// RewardedAdsVerifier 는 tink 라이브러리로 검증 할 수 있다.
    private val verifier = RewardedAdsVerifier.Builder()
        .fetchVerifyingPublicKeysWith(RewardedAdsVerifier.KEYS_DOWNLOADER_INSTANCE_PROD)
        .build()

클라이언트 -> my 서버로 요청 (4번 단계)

data class RewardRequest(
    val sessionId: String
)

@PostMapping
fun pig(@RequestBody dto: RewardRequest) {
        service.pigHistoryRegisterV2(dto, getAuthReq())
}

  fun pigHistoryRegisterV2(dto: RewardRequest): Int {
        verificationManager.claimUserReward(dto.sessionId, customerId)
        ....
        //리워드 지급 로직
        return amount
    }
    
 private val adsRewardKey = "ad:reward:temp:"
 
 fun claimUserReward(sessionId: String): Boolean {
        val key = "$adsRewardKey$sessionId"
        // Redis 에 저장된 키를 삭제 해준다. 없으면 false 로 유효하지 않은 Key
        val deleted = redisTemplate.delete(key)

        if (deleted != true) {
            throw NoSuchElementException("유효하지 않거나 이미 사용된 보상입니다.")
        }

        // 광고 지급 저장 로직...

        return true
    }

[오류노트] Apple 소셜로그인

imSoo — Mon, 22 Dec 2025 19:11:04 +0900

problem

백엔드에서 아래 url 로 code 인증을 보낼때 invalid_client 에러가 떴다.

"/auth/token"

solution

1. apple_key 변경

2.client_id 확인

3. jwt sign 에 사용하는 p8 키가 위 apple key 와 같은 파일인지 확인

위 사항을 확인하면 되는데,

identifier 을 client_id 에 잘 넣어주었는지 확인하고,

key 를 새로 발급받아서 p8 키를 아예 새로 발급받아서 다시 넣어주자.

[Spring] Apple 소셜 로그인 구현 (f.Expo)

imSoo — Wed, 17 Dec 2025 10:44:47 +0900

@Component
class AppleKeyLocator(
    private val appleKeyClient: AppleKeyClient
) {
    fun genaratePublicK(token: String): PublicKey {
        val headerPart = token.substringBefore('.')

        val header = ObjectMapper().readValue(
            String(Base64.getUrlDecoder().decode(headerPart), Charsets.UTF_8),
            object : TypeReference<Map<String, String>>() {}
        )

        require(header["alg"] == "RS256") {
            "Unsupported JWT algorithm: ${header["alg"]}"
        }

        val publicKeys = appleKeyClient.getPublicKeys()

        val key = publicKeys.keys.firstOrNull {
            it.kid == header["kid"] && it.alg == "RS256"
        } ?: throw IllegalArgumentException("Matching Apple Public Key not found")

        val modulus = BigInteger(1, Base64.getUrlDecoder().decode(key.n))
        val exponent = BigInteger(1, Base64.getUrlDecoder().decode(key.e))

        return KeyFactory.getInstance("RSA")
            .generatePublic(RSAPublicKeySpec(modulus, exponent))
    }
}

이 글은 사용자가 Front 에서 인증 완료 후 토큰을 받아 Backend 에서 Apple 로 검증 하는 방법을 설명한다.

구성 환경

React Native(Expo) -> Expo go (x)

Spring boot

프론트에서 받아 올 것

Apple 인증을 받으려면

identityToken , authorizationCode 를 받아와야 한다.

1. 인증서 생성

인증서,ID 및 프로파일 -> 인증서 탭을 누르면 아래 화면이 나온다.

Identifiers 의 + 버튼을 누르고

Front 의 환경이

App -> APP IDs

Web -> Services IDs

를 만들어준다.

필자는 앱 환경이기 때문에 App IDs 를 만든다.

Bundle ID 를 입력 해준다.

이 부분은 앱 패키지 ID랑은 별개이다.

보통 패키지 명(com.exam.myapp)을 사용 하는데, Services ID 와 App ID 를 구분짓기 위해,

appID.com.exam.myapp

servicesID.com.exam.myapp

로 만들기도 한다. 번들 ID 는 중복이 안됨.

아래에 sign In with Apple 을 추가 해준다.

Edit 창에 들어가서 아래 Primary App 을 선택 해준다.

생성 완료 후,

Team ID, Bundle ID 를 기록 해두자.

2. Key 생성

아래에 Keys 탭에 + 버튼을 눌러 키를 생성해준다.

키를 만들고 Key ID 를 메모 해두자.

코드

//gradle
implementation("io.jsonwebtoken:jjwt-api:0.12.6")
implementation("io.jsonwebtoken:jjwt-impl:0.12.6")
implementation("io.jsonwebtoken:jjwt-jackson:0.12.6")

Apple 은 인증 수단으로 JWT 토큰을 사용한다.

JWT 토큰을 만들어서 Apple 로 인증 받는 과정이 있음.

전체코드

// Request Dto
class OauthSignUpRequestDto(
    val token: String,
    val appleCode: String?,
)

// 전체코드
fun getEmailAndValidateToken(request: OauthSignUpRequestDto): String {
        val jwt = appleJwtUtil.generateAuthJwt()
        val code = request.appleCode ?: throw IllegalArgumentException("애플 코드가 존재하지 않습니다.")

        try {
            val response = webClient.post()
                .uri { uriBuilder ->
                    uriBuilder.path("/auth/token")
                        .queryParam("grant_type", "authorization_code")
                        .queryParam("client_id", clientId)
                        .queryParam("client_secret", jwt)
                        .queryParam("code", code)
                        .build()
                }
                .retrieve()
                .bodyToMono(AppleTokenResponseDto::class.java)
                .block() ?: throw ExternalApiErrorException("Apple token response was null")
            val claims = appleJwtUtil.extractAuthClaims(response.idToken!!)
            val identifier = claims.get("sub", String::class.java)
            return identifier

        } catch (e: WebClientResponseException) {
            log.error("[애플 로그인 실패]: ${e.responseBodyAsString}", e)
            throw e
        } catch (e: Exception) {
            log.error("[애플 로그인 실패 - 예상치 못한 오류]: ${e.message}", e)
            throw e
        }
    }

Jwt Token 생성 (apple 인증용)

 @Value("\${apple_identifier_bundle_id}")
    private lateinit var bundleId: String

    @Value("\${apple_team_id}")
    private lateinit var teamId: String

    @Value("\${apple_key_id}")
    private lateinit var keyId: String

    fun generateAuthJwt(): String {
        val now = System.currentTimeMillis()
        val iat = Date(now)
        val exp = Date(now + 20 * 60 * 1000)
        val privateKey = keyManager.loadPrivateKeyForApple(AppleKeyType.AUTH)

        return Jwts.builder()
            .subject(bundleId) 
            .issuer(teamId)
            .issuedAt(iat)
            .expiration(exp)
            .audience()
            .add("https://appleid.apple.com")
            .and()
            .header()
            .keyId(keyId)
            .and()
            .signWith(privateKey, Jwts.SIG.ES256)
            .compact()
    }

위에서 저장한

BundleId, TeamId, KeyId 를 환경변수에 넣어

Jwt 토큰을 만들어준다.

토큰 인증

        
        
        val jwt = appleJwtUtil.generateAuthJwt()
        val code = request.appleCode ?: throw IllegalArgumentException("애플 코드가 존재하지 않습니다.")

        try {
            val response = webClient.post()
                .uri { uriBuilder ->
                    uriBuilder.path("/auth/token")
                        .queryParam("grant_type", "authorization_code")
                        //ClientId 는 위에서 사용한 Bundle Id가 들어간다.
                        .queryParam("client_id", clientId)
                        // 위에서 생성한 JWT 토큰
                        .queryParam("client_secret", jwt)
                        // Front 에서 받아온 authorizationCode
                        .queryParam("code", code)
                        .build()
                }
                .retrieve()
                .bodyToMono(AppleTokenResponseDto::class.java)
                .block() ?: throw ExternalApiErrorException("Apple token response was null")

// APPLE 응답 Dto
@JsonIgnoreProperties(ignoreUnknown = true)
data class AppleTokenResponseDto(
    @JsonProperty("access_token")
    val accessToken: String?,

    @JsonProperty("token_type")
    val tokenType: String?,

    @JsonProperty("expires_in")
    val expiresIn: String?,

    @JsonProperty("refresh_token")
    val refreshToken: String?,

    @JsonProperty("id_token")
    val idToken: String?
)

이렇게 토큰이 실제 하는지 인증을 하면 끝난다.

APPLE 은 사용자가 이메일을 가려서 가입 할 수 있는데, 이때 사용자를 식별할만한 무언가를 만들어주어야 한다.

토큰 정보 추출

   fun extractAuthClaims(token: String): Claims {
        try {
            val key = appleKeyClient.genaratePublicK(token)
            return Jwts.parser()
                .verifyWith(key)
                .build()
                .parseSignedClaims(idToken)
                .payload
        } catch (e: ExpiredJwtException) {
            throw ExpiredJwtException(e.header, e.claims, "Apple JWT 토큰이 만료되었습니다.")
        }
    }

받아온 토큰으로 public Key 를 만들어준다.

@Component
class AppleKey(
    private val appleKeyClient: AppleKeyClient
) {
    fun genaratePublicK(token: String): PublicKey {
        val headerPart = token.substringBefore('.')

        val header = ObjectMapper().readValue(
            String(Base64.getUrlDecoder().decode(headerPart), Charsets.UTF_8),
            object : TypeReference<Map<String, String>>() {}
        )

        require(header["alg"] == "RS256") {
            "Unsupported JWT algorithm: ${header["alg"]}"
        }
		
        // !!! 애플에서 Key 를 받아와야 함. 캐시 처리를 해주자
        val publicKeys = appleKeyClient.getPublicKeys()

        val key = publicKeys.keys.firstOrNull {
            it.kid == header["kid"] && it.alg == "RS256"
        } ?: throw IllegalArgumentException("Matching Apple Public Key not found")

        val modulus = BigInteger(1, Base64.getUrlDecoder().decode(key.n))
        val exponent = BigInteger(1, Base64.getUrlDecoder().decode(key.e))

        return KeyFactory.getInstance("RSA")
            .generatePublic(RSAPublicKeySpec(modulus, exponent))
    }
}

// Openfeign 을 사용하였다 webClient 를 사용해도됨
@FeignClient(name = "apple-auth", url = "https://appleid.apple.com/auth")
interface AppleKeyClient {

    @GetMapping("/keys")
    fun getPublicKeys(): ApplePublicKeysResponse
}

data class ApplePublicKeysResponse(
    val keys: List<ApplePublicKeyResponseDto>
) {
    data class ApplePublicKeyResponseDto(
        val kty: String, // Key Type (예: RSA)
        val kid: String, // Key ID
        val use: String,
        val alg: String,
        val n: String,   // Modulus (Base64 URL-safe)
        val e: String    // Public Exponent (Base64 URL-safe)
    )
}

받아오면 키 조합들이 응답으로 오는데, 이 조합으로 온 키 중 RS256 을 사용하여 Public Key 를 만들어준다.

Claims 를 까보면 위와 같이 되어 있는데, 이 중

"Sub" 로 유저의 고유의 값을 처리 해주면 된다.

[오류노트] nextJS 취약점 업데이트 (f.expo)

imSoo — Wed, 10 Dec 2025 10:33:19 +0900

problem

next 취약점 이슈로 인해 react 버전을 업데이트 해주어야 했다.

사내 프로젝트가 모노레포로 되어 있어서 react 를 19.0.1 버전으로 업데이트를 해야 하는 상황이었다.

업데이트 진행 도중 react 와 react-native-renderer 버전이 맞지 않다고 오류가 떴다.

solution

//app.json

"expo":{
  "experiments": {
      "reactCanary": true
    }
}

expo 블록에 위 코드를 추가해주었다.

이 옵션은 Expo 에서 React의 Canary 실험용 최신버전 기능을 강제로 사용할 수 있도록 열어두는 플래그이다.

https://expo.dev/changelog/mitigating-critical-security-vulnerability-in-react-server-components

Mitigating the Critical Security Vulnerability in React Server Components - Expo Changelog

Check out new updates and improvements to Expo and EAS from the Expo team.

expo.dev